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

Pull networking fixes from David Miller: 1) ICE, E1000, IGB, IXGBE, and I40E bug fixes from the Intel folks. 2) Better fix for AB-BA deadlock in packet scheduler code, from Cong Wang. 3) bpf sockmap fixes (zero sized key handling, etc.) from Daniel Borkmann. 4) Send zero IPID in TCP resets and SYN-RECV state ACKs, to prevent attackers using it as a side-channel. From Eric Dumazet. 5) Memory leak in mediatek bluetooth driver, from Gustavo A. R. Silva. 6) Hook up rt->dst.input of ipv6 anycast routes properly, from Hangbin Liu. 7) hns and hns3 bug fixes from Huazhong Tan. 8) Fix RIF leak in mlxsw driver, from Ido Schimmel. 9) iova range check fix in vhost, from Jason Wang. 10) Fix hang in do_tcp_sendpages() with tls, from John Fastabend. 11) More r8152 chips need to disable RX aggregation, from Kai-Heng Feng. 12) Memory exposure in TCA_U32_SEL handling, from Kees Cook. 13) TCP BBR congestion control fixes from Kevin Yang. 14) hv_netvsc, ignore non-PCI devices, from Stephen Hemminger. 15) qed driver fixes from Tomer Tayar. * git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (77 commits) net: sched: Fix memory exposure from short TCA_U32_SEL qed: fix spelling mistake "comparsion" -> "comparison" vhost: correctly check the iova range when waking virtqueue qlge: Fix netdev features configuration. net: macb: do not disable MDIO bus at open/close time Revert "net: stmmac: fix build failure due to missing COMMON_CLK dependency" net: macb: Fix regression breaking non-MDIO fixed-link PHYs mlxsw: spectrum_switchdev: Do not leak RIFs when removing bridge i40e: fix condition of WARN_ONCE for stat strings i40e: Fix for Tx timeouts when interface is brought up if DCB is enabled ixgbe: fix driver behaviour after issuing VFLR ixgbe: Prevent unsupported configurations with XDP ixgbe: Replace GFP_ATOMIC with GFP_KERNEL igb: Replace mdelay() with msleep() in igb_integrated_phy_loopback() igb: Replace GFP_ATOMIC with GFP_KERNEL in igb_sw_init() igb: Use an advanced ctx descriptor for launchtime e1000: ensure to free old tx/rx rings in set_ringparam() e1000: check on netif_running() before calling e1000_up() ixgb: use dma_zalloc_coherent instead of allocator/memset ice: Trivial formatting fixes ...

Linus Torvalds committed 8 years ago

Commit 050cdc62 parents 908946c 98c8f1292 files · +754 −711Browse files

Unified · Split

92 files

drivers/bluetooth/Kconfig +1 −0
drivers/bluetooth/btmtkuart.c +5 −3
drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c +2 −4
drivers/net/ethernet/cadence/macb_main.c +23 −13
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c +4 −6
drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_u32.c +2 −3
drivers/net/ethernet/hisilicon/hns/hnae.h +3 −3
drivers/net/ethernet/hisilicon/hns/hns_enet.c +4 −104
drivers/net/ethernet/hisilicon/hns3/hns3_enet.c +2 −1
drivers/net/ethernet/hisilicon/hns3/hns3_enet.h +3 −3
drivers/net/ethernet/intel/e1000/e1000_ethtool.c +4 −3
drivers/net/ethernet/intel/i40e/i40e_ethtool.c +1 −1
drivers/net/ethernet/intel/i40e/i40e_main.c +8 −7
drivers/net/ethernet/intel/ice/ice.h +11 −4
drivers/net/ethernet/intel/ice/ice_adminq_cmd.h +13 −12
drivers/net/ethernet/intel/ice/ice_common.c +18 −12
drivers/net/ethernet/intel/ice/ice_controlq.c +20 −9
drivers/net/ethernet/intel/ice/ice_ethtool.c +39 −13
drivers/net/ethernet/intel/ice/ice_hw_autogen.h +0 −8
drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h +1 −0
drivers/net/ethernet/intel/ice/ice_main.c +66 −49
drivers/net/ethernet/intel/ice/ice_nvm.c +2 −3
drivers/net/ethernet/intel/ice/ice_sched.c +1 −2
drivers/net/ethernet/intel/ice/ice_switch.c +2 −2
drivers/net/ethernet/intel/ice/ice_switch.h +3 −3
drivers/net/ethernet/intel/ice/ice_txrx.h +1 −1
drivers/net/ethernet/intel/ice/ice_type.h +8 −8
drivers/net/ethernet/intel/igb/igb_ethtool.c +1 −1
drivers/net/ethernet/intel/igb/igb_main.c +4 −3
drivers/net/ethernet/intel/ixgb/ixgb_main.c +2 −3
drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c +2 −2
drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +29 −7
drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c +31 −0
drivers/net/ethernet/intel/ixgbe/ixgbe_type.h +1 −0
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +9 −10
drivers/net/ethernet/mellanox/mlxsw/spectrum.c +1 −2
drivers/net/ethernet/mellanox/mlxsw/spectrum.h +2 −0
drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c +2 −4
drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c +11 −0
drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c +20 −0
drivers/net/ethernet/netronome/nfp/flower/action.c +2 −4
drivers/net/ethernet/qlogic/qed/qed_init_ops.c +1 −1
drivers/net/ethernet/qlogic/qed/qed_mcp.c +158 −29
drivers/net/ethernet/qlogic/qed/qed_mcp.h +18 −9
drivers/net/ethernet/qlogic/qed/qed_reg_addr.h +2 −0
drivers/net/ethernet/qlogic/qede/qede_filter.c +2 −4
drivers/net/ethernet/qlogic/qlge/qlge_main.c +8 −15
drivers/net/ethernet/renesas/ravb.h +1 −4
drivers/net/ethernet/renesas/ravb_main.c +1 −4
drivers/net/ethernet/renesas/sh_eth.c +1 −12
drivers/net/ethernet/renesas/sh_eth.h +1 −12
drivers/net/ethernet/stmicro/stmmac/Kconfig +5 −5
drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c +2 −3
drivers/net/hyperv/netvsc_drv.c +5 −0
drivers/net/usb/r8152.c +2 −2
drivers/vhost/vhost.c +1 −1
include/net/act_api.h +0 −7
include/net/pkt_cls.h +14 −11
kernel/bpf/hashtab.c +13 −10
kernel/bpf/sockmap.c +9 −2
lib/rhashtable.c +0 −1
net/dsa/slave.c +1 −3
net/ipv4/tcp_bbr.c +24 −18
net/ipv4/tcp_ipv4.c +6 −0
net/ipv6/addrconf.c +3 −3
net/ipv6/ip6_fib.c +2 −0
net/ipv6/ip6_vti.c +2 −1
net/ipv6/route.c +1 −1
net/ncsi/ncsi-netlink.c +2 −2
net/rds/tcp.c +0 −1
net/sched/act_api.c +25 −45
net/sched/act_bpf.c +0 −8
net/sched/act_connmark.c +0 −8
net/sched/act_csum.c +0 −8
net/sched/act_gact.c +0 −8
net/sched/act_ife.c +40 −52
net/sched/act_ipt.c +0 −16
net/sched/act_mirred.c +0 −8
net/sched/act_nat.c +0 −8
net/sched/act_pedit.c +0 −8
net/sched/act_police.c +0 −8
net/sched/act_sample.c +0 −8
net/sched/act_simple.c +0 −8
net/sched/act_skbedit.c +0 −8
net/sched/act_skbmod.c +0 −8
net/sched/act_tunnel_key.c +0 −8
net/sched/act_vlan.c +0 −8
net/sched/cls_u32.c +8 −2
net/sched/sch_cake.c +19 −5
net/tls/tls_main.c +7 −2
net/xdp/xdp_umem.c +2 −2
tools/bpf/bpftool/map_perf_ring.c +4 −1

drivers/bluetooth/Kconfig+1−0

@@ -200,6 +200,7 @@ config BT_HCIUART_RTL · 199 unmodified lines
200	depends on BT_HCIUART	200	depends on BT_HCIUART
201	depends on BT_HCIUART_SERDEV	201	depends on BT_HCIUART_SERDEV
202	depends on GPIOLIB	202	depends on GPIOLIB
		203	depends on ACPI
203	select BT_HCIUART_3WIRE	204	select BT_HCIUART_3WIRE
204	select BT_RTL	205	select BT_RTL
205	help	206	help

drivers/bluetooth/btmtkuart.c+5−3

 	fw_size = fw->size;
 	/* The size of patch header is 30 bytes, should be skip */
-	if (fw_size < 30)
+	if (fw_size < 30) {
-		return -EINVAL;
+		err = -EINVAL;
+		goto free_fw;
+	}
 	fw_size -= 30;
 	fw_ptr += 30;
 		fw_ptr += dlen;
 	}
+free_fw:
 	release_firmware(fw);
 	return err;
 }

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c+2−4

 				 struct tcf_exts *tc_exts)
 {
 	const struct tc_action *tc_act;
-	LIST_HEAD(tc_actions);
+	int i, rc;
-	int rc;
 	if (!tcf_exts_has_actions(tc_exts)) {
 		netdev_info(bp->dev, "no actions");
 		return -EINVAL;
 	}
-	tcf_exts_to_list(tc_exts, &tc_actions);
+	tcf_exts_for_each_action(i, tc_act, tc_exts) {
-	list_for_each_entry(tc_act, &tc_actions, list) {
 		/* Drop action */
 		if (is_tcf_gact_shot(tc_act)) {
 			actions->flags |= BNXT_TC_ACTION_FLAG_DROP;

drivers/net/ethernet/cadence/macb_main.c+23−13

 	if (np) {
 		if (of_phy_is_fixed_link(np)) {
-			if (of_phy_register_fixed_link(np) < 0) {
-				dev_err(&bp->pdev->dev,
-					"broken fixed-link specification\n");
-				return -ENODEV;
-			}
 			bp->phy_node = of_node_get(np);
 		} else {
 			bp->phy_node = of_parse_phandle(np, "phy-handle", 0);
 {
 	struct macb_platform_data *pdata;
 	struct device_node *np;
-	int err;
+	int err = -ENXIO;
 	/* Enable management port */
 	macb_writel(bp, NCR, MACB_BIT(MPE));
 	dev_set_drvdata(&bp->dev->dev, bp->mii_bus);
 	np = bp->pdev->dev.of_node;
-	if (pdata)
+	if (np && of_phy_is_fixed_link(np)) {
-		bp->mii_bus->phy_mask = pdata->phy_mask;
+		if (of_phy_register_fixed_link(np) < 0) {
+			dev_err(&bp->pdev->dev,
+				"broken fixed-link specification %pOF\n", np);
+			goto err_out_free_mdiobus;
+		}
+		err = mdiobus_register(bp->mii_bus);
+	} else {
+		if (pdata)
+			bp->mii_bus->phy_mask = pdata->phy_mask;
+		err = of_mdiobus_register(bp->mii_bus, np);
+	}
-	err = of_mdiobus_register(bp->mii_bus, np);
 	if (err)
-		goto err_out_free_mdiobus;
+		goto err_out_free_fixed_link;
 	err = macb_mii_probe(bp->dev);
 	if (err)
 err_out_unregister_bus:
 	mdiobus_unregister(bp->mii_bus);
+err_out_free_fixed_link:
 	if (np && of_phy_is_fixed_link(np))
 		of_phy_deregister_fixed_link(np);
 err_out_free_mdiobus:
 {
 	struct macb_queue *queue;
 	unsigned int q;
+	u32 ctrl = macb_readl(bp, NCR);
 	/* Disable RX and TX (XXX: Should we halt the transmission
 	 * more gracefully?)
 	 */
-	macb_writel(bp, NCR, 0);
+	ctrl &= ~(MACB_BIT(RE) | MACB_BIT(TE));
 	/* Clear the stats registers (XXX: Update stats first?) */
-	macb_writel(bp, NCR, MACB_BIT(CLRSTAT));
+	ctrl |= MACB_BIT(CLRSTAT);
+	macb_writel(bp, NCR, ctrl);
 	/* Clear all status flags */
 	macb_writel(bp, TSR, -1);
 	}
 	/* Enable TX and RX */
-	macb_writel(bp, NCR, MACB_BIT(RE) | MACB_BIT(TE) | MACB_BIT(MPE));
+	macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(RE) | MACB_BIT(TE));
 }
 /* The hash address register is 64 bits long and takes up two

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c+4−6

 				       struct ch_filter_specification *fs)
 {
 	const struct tc_action *a;
-	LIST_HEAD(actions);
+	int i;
-	tcf_exts_to_list(cls->exts, &actions);
+	tcf_exts_for_each_action(i, a, cls->exts) {
-	list_for_each_entry(a, &actions, list) {
 		if (is_tcf_gact_ok(a)) {
 			fs->action = FILTER_PASS;
 		} else if (is_tcf_gact_shot(a)) {
 	bool act_redir = false;
 	bool act_pedit = false;
 	bool act_vlan = false;
-	LIST_HEAD(actions);
+	int i;
-	tcf_exts_to_list(cls->exts, &actions);
+	tcf_exts_for_each_action(i, a, cls->exts) {
-	list_for_each_entry(a, &actions, list) {
 		if (is_tcf_gact_ok(a)) {
 			/* Do nothing */
 		} else if (is_tcf_gact_shot(a)) {

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_u32.c+2−3

 	unsigned int num_actions = 0;
 	const struct tc_action *a;
 	struct tcf_exts *exts;
-	LIST_HEAD(actions);
+	int i;
 	exts = cls->knode.exts;
 	if (!tcf_exts_has_actions(exts))
 		return -EINVAL;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		/* Don't allow more than one action per rule. */
 		if (num_actions)
 			return -EINVAL;

drivers/net/ethernet/hisilicon/hns/hnae.h+3−3

@@ -220,10 +220,10 @@ struct hnae_desc_cb { · 219 unmodified lines
220		220
221	/* priv data for the desc, e.g. skb when use with ip stack*/	221	/* priv data for the desc, e.g. skb when use with ip stack*/
222	void *priv;	222	void *priv;
223	u16 page_offset;	223	u32 page_offset;
224	u16 reuse_flag;	224	u32 length; /* length of the buffer */
225		225
226	u16 length; /* length of the buffer */	226	u16 reuse_flag;
227		227
228	/* desc type, used by the ring user to mark the type of the priv data */	228	/* desc type, used by the ring user to mark the type of the priv data */
229	u16 type;	229	u16 type;

drivers/net/ethernet/hisilicon/hns/hns_enet.c+4−104

@@ -406,113 +406,13 @@ out_net_tx_busy: · 405 unmodified lines
406	return NETDEV_TX_BUSY;	406	return NETDEV_TX_BUSY;
407	}	407	}
408		408
409	/**
410	* hns_nic_get_headlen - determine size of header for RSC/LRO/GRO/FCOE
411	* @data: pointer to the start of the headers
412	* @max: total length of section to find headers in
413	*
414	* This function is meant to determine the length of headers that will
415	* be recognized by hardware for LRO, GRO, and RSC offloads. The main
416	* motivation of doing this is to only perform one pull for IPv4 TCP
417	* packets so that we can do basic things like calculating the gso_size
418	* based on the average data per packet.
419	**/
420	static unsigned int hns_nic_get_headlen(unsigned char *data, u32 flag,
421	unsigned int max_size)
422	{
423	unsigned char *network;
424	u8 hlen;
425
426	/* this should never happen, but better safe than sorry */
427	if (max_size < ETH_HLEN)
428	return max_size;
429
430	/* initialize network frame pointer */
431	network = data;
432
433	/* set first protocol and move network header forward */
434	network += ETH_HLEN;
435
436	/* handle any vlan tag if present */
437	if (hnae_get_field(flag, HNS_RXD_VLAN_M, HNS_RXD_VLAN_S)
438	== HNS_RX_FLAG_VLAN_PRESENT) {
439	if ((typeof(max_size))(network - data) > (max_size - VLAN_HLEN))
440	return max_size;
441
442	network += VLAN_HLEN;
443	}
444
445	/* handle L3 protocols */
446	if (hnae_get_field(flag, HNS_RXD_L3ID_M, HNS_RXD_L3ID_S)
447	== HNS_RX_FLAG_L3ID_IPV4) {
448	if ((typeof(max_size))(network - data) >
449	(max_size - sizeof(struct iphdr)))
450	return max_size;
451
452	/* access ihl as a u8 to avoid unaligned access on ia64 */
453	hlen = (network[0] & 0x0F) << 2;
454
455	/* verify hlen meets minimum size requirements */
456	if (hlen < sizeof(struct iphdr))
457	return network - data;
458
459	/* record next protocol if header is present */
460	} else if (hnae_get_field(flag, HNS_RXD_L3ID_M, HNS_RXD_L3ID_S)
461	== HNS_RX_FLAG_L3ID_IPV6) {
462	if ((typeof(max_size))(network - data) >
463	(max_size - sizeof(struct ipv6hdr)))
464	return max_size;
465
466	/* record next protocol */
467	hlen = sizeof(struct ipv6hdr);
468	} else {
469	return network - data;
470	}
471
472	/* relocate pointer to start of L4 header */
473	network += hlen;
474
475	/* finally sort out TCP/UDP */
476	if (hnae_get_field(flag, HNS_RXD_L4ID_M, HNS_RXD_L4ID_S)
477	== HNS_RX_FLAG_L4ID_TCP) {
478	if ((typeof(max_size))(network - data) >
479	(max_size - sizeof(struct tcphdr)))
480	return max_size;
481
482	/* access doff as a u8 to avoid unaligned access on ia64 */
483	hlen = (network[12] & 0xF0) >> 2;
484
485	/* verify hlen meets minimum size requirements */
486	if (hlen < sizeof(struct tcphdr))
487	return network - data;
488
489	network += hlen;
490	} else if (hnae_get_field(flag, HNS_RXD_L4ID_M, HNS_RXD_L4ID_S)
491	== HNS_RX_FLAG_L4ID_UDP) {
492	if ((typeof(max_size))(network - data) >
493	(max_size - sizeof(struct udphdr)))
494	return max_size;
495
496	network += sizeof(struct udphdr);
497	}
498
499	/* If everything has gone correctly network should be the
500	* data section of the packet and will be the end of the header.
501	* If not then it probably represents the end of the last recognized
502	* header.
503	*/
504	if ((typeof(max_size))(network - data) < max_size)
505	return network - data;
506	else
507	return max_size;
508	}
509
510	static void hns_nic_reuse_page(struct sk_buff *skb, int i,	409	static void hns_nic_reuse_page(struct sk_buff *skb, int i,
511	struct hnae_ring *ring, int pull_len,	410	struct hnae_ring *ring, int pull_len,
512	struct hnae_desc_cb *desc_cb)	411	struct hnae_desc_cb *desc_cb)
513	{	412	{
514	struct hnae_desc *desc;	413	struct hnae_desc *desc;
515	int truesize, size;	414	u32 truesize;
		415	int size;
516	int last_offset;	416	int last_offset;
517	bool twobufs;	417	bool twobufs;
518		418
@@ -530,7 +430,7 @@ static void hns_nic_reuse_page(struct sk_buff *skb, int i, · 11 unmodified lines
530	}	430	}
531		431
532	skb_add_rx_frag(skb, i, desc_cb->priv, desc_cb->page_offset + pull_len,	432	skb_add_rx_frag(skb, i, desc_cb->priv, desc_cb->page_offset + pull_len,
533	size - pull_len, truesize - pull_len);	433	size - pull_len, truesize);
534		434
535	/* avoid re-using remote pages,flag default unreuse */	435	/* avoid re-using remote pages,flag default unreuse */
536	if (unlikely(page_to_nid(desc_cb->priv) != numa_node_id()))	436	if (unlikely(page_to_nid(desc_cb->priv) != numa_node_id()))
@@ -695,7 +595,7 @@ static int hns_nic_poll_rx_skb(struct hns_nic_ring_data *ring_data, · 158 unmodified lines
695	} else {	595	} else {
696	ring->stats.seg_pkt_cnt++;	596	ring->stats.seg_pkt_cnt++;
697		597
698	pull_len = hns_nic_get_headlen(va, bnum_flag, HNS_RX_HEAD_SIZE);	598	pull_len = eth_get_headlen(va, HNS_RX_HEAD_SIZE);
699	memcpy(__skb_put(skb, pull_len), va,	599	memcpy(__skb_put(skb, pull_len), va,
700	ALIGN(pull_len, sizeof(long)));	600	ALIGN(pull_len, sizeof(long)));
701		601

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c+2−1

@@ -2019,7 +2019,8 @@ static void hns3_nic_reuse_page(struct sk_buff *skb, int i, · 2018 unmodified lines
2019	struct hns3_desc_cb *desc_cb)	2019	struct hns3_desc_cb *desc_cb)
2020	{	2020	{
2021	struct hns3_desc *desc;	2021	struct hns3_desc *desc;
2022	int truesize, size;	2022	u32 truesize;
		2023	int size;
2023	int last_offset;	2024	int last_offset;
2024	bool twobufs;	2025	bool twobufs;
2025		2026

drivers/net/ethernet/hisilicon/hns3/hns3_enet.h+3−3

 	/* priv data for the desc, e.g. skb when use with ip stack*/
 	void *priv;
-	u16 page_offset;
+	u32 page_offset;
-	u16 reuse_flag;
 	u32 length;     /* length of the buffer */
+	u16 reuse_flag;
        /* desc type, used by the ring user to mark the type of the priv data */
 	u16 type;
 };

drivers/net/ethernet/intel/e1000/e1000_ethtool.c+4−3

 		adapter->tx_ring = tx_old;
 		e1000_free_all_rx_resources(adapter);
 		e1000_free_all_tx_resources(adapter);
-		kfree(tx_old);
-		kfree(rx_old);
 		adapter->rx_ring = rxdr;
 		adapter->tx_ring = txdr;
 		err = e1000_up(adapter);
 		if (err)
 			goto err_setup;
 	}
+	kfree(tx_old);
+	kfree(rx_old);
 	clear_bit(__E1000_RESETTING, &adapter->flags);
 	return 0;
 err_alloc_rx:
 	kfree(txdr);
 err_alloc_tx:
-	e1000_up(adapter);
+	if (netif_running(adapter->netdev))
+		e1000_up(adapter);
 err_setup:
 	clear_bit(__E1000_RESETTING, &adapter->flags);
 	return err;

drivers/net/ethernet/intel/i40e/i40e_ethtool.c+1−1

@@ -2013,7 +2013,7 @@ static void i40e_get_stat_strings(struct net_device netdev, u8 data) · 2012 unmodified lines
2013	for (i = 0; i < I40E_MAX_USER_PRIORITY; i++)	2013	for (i = 0; i < I40E_MAX_USER_PRIORITY; i++)
2014	i40e_add_stat_strings(&data, i40e_gstrings_pfc_stats, i);	2014	i40e_add_stat_strings(&data, i40e_gstrings_pfc_stats, i);
2015		2015
2016	WARN_ONCE(p - data != i40e_get_stats_count(netdev) * ETH_GSTRING_LEN,	2016	WARN_ONCE(data - p != i40e_get_stats_count(netdev) * ETH_GSTRING_LEN,
2017	"stat strings count mismatch!");	2017	"stat strings count mismatch!");
2018	}	2018	}
2019		2019

drivers/net/ethernet/intel/i40e/i40e_main.c+8−7

 				       u8 *bw_share)
 {
 	struct i40e_aqc_configure_vsi_tc_bw_data bw_data;
+	struct i40e_pf *pf = vsi->back;
 	i40e_status ret;
 	int i;
-	if (vsi->back->flags & I40E_FLAG_TC_MQPRIO)
+	/* There is no need to reset BW when mqprio mode is on.  */
+	if (pf->flags & I40E_FLAG_TC_MQPRIO)
 		return 0;
-	if (!vsi->mqprio_qopt.qopt.hw) {
+	if (!vsi->mqprio_qopt.qopt.hw && !(pf->flags & I40E_FLAG_DCB_ENABLED)) {
 		ret = i40e_set_bw_limit(vsi, vsi->seid, 0);
 		if (ret)
-			dev_info(&vsi->back->pdev->dev,
+			dev_info(&pf->pdev->dev,
 				 "Failed to reset tx rate for vsi->seid %u\n",
 				 vsi->seid);
 		return ret;
 	for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++)
 		bw_data.tc_bw_credits[i] = bw_share[i];
-	ret = i40e_aq_config_vsi_tc_bw(&vsi->back->hw, vsi->seid, &bw_data,
+	ret = i40e_aq_config_vsi_tc_bw(&pf->hw, vsi->seid, &bw_data, NULL);
-				       NULL);
 	if (ret) {
-		dev_info(&vsi->back->pdev->dev,
+		dev_info(&pf->pdev->dev,
 			 "AQ command Config VSI BW allocation per TC failed = %d\n",
-			 vsi->back->hw.aq.asq_last_status);
+			 pf->hw.aq.asq_last_status);
 		return -EINVAL;
 	}

drivers/net/ethernet/intel/ice/ice.h+11−4

 #define ice_for_each_rxq(vsi, i) \
 	for ((i) = 0; (i) < (vsi)->num_rxq; (i)++)
+/* Macros for each allocated tx/rx ring whether used or not in a VSI */
+#define ice_for_each_alloc_txq(vsi, i) \
+	for ((i) = 0; (i) < (vsi)->alloc_txq; (i)++)
+#define ice_for_each_alloc_rxq(vsi, i) \
+	for ((i) = 0; (i) < (vsi)->alloc_rxq; (i)++)
 struct ice_tc_info {
 	u16 qoffset;
 	u16 qcount;
 	struct list_head tmp_sync_list;		/* MAC filters to be synced */
 	struct list_head tmp_unsync_list;	/* MAC filters to be unsynced */
-	bool irqs_ready;
+	u8 irqs_ready;
-	bool current_isup;		 /* Sync 'link up' logging */
+	u8 current_isup;		 /* Sync 'link up' logging */
-	bool stat_offsets_loaded;
+	u8 stat_offsets_loaded;
 	/* queue information */
 	u8 tx_mapping_mode;		 /* ICE_MAP_MODE_[CONTIG|SCATTER] */
 	struct ice_hw_port_stats stats;
 	struct ice_hw_port_stats stats_prev;
 	struct ice_hw hw;
-	bool stat_prev_loaded;	/* has previous stats been loaded */
+	u8 stat_prev_loaded;	/* has previous stats been loaded */
 	char int_name[ICE_INT_NAME_STR_LEN];
 };

drivers/net/ethernet/intel/ice/ice_adminq_cmd.h+13−12

@@ -329,19 +329,19 @@ struct ice_aqc_vsi_props { · 328 unmodified lines
329	/* VLAN section */	329	/* VLAN section */
330	__le16 pvid; /* VLANS include priority bits */	330	__le16 pvid; /* VLANS include priority bits */
331	u8 pvlan_reserved[2];	331	u8 pvlan_reserved[2];
332	u8 port_vlan_flags;	332	u8 vlan_flags;
333	#define ICE_AQ_VSI_PVLAN_MODE_S 0	333	#define ICE_AQ_VSI_VLAN_MODE_S 0
334	#define ICE_AQ_VSI_PVLAN_MODE_M (0x3 << ICE_AQ_VSI_PVLAN_MODE_S)	334	#define ICE_AQ_VSI_VLAN_MODE_M (0x3 << ICE_AQ_VSI_VLAN_MODE_S)
335	#define ICE_AQ_VSI_PVLAN_MODE_UNTAGGED 0x1	335	#define ICE_AQ_VSI_VLAN_MODE_UNTAGGED 0x1
336	#define ICE_AQ_VSI_PVLAN_MODE_TAGGED 0x2	336	#define ICE_AQ_VSI_VLAN_MODE_TAGGED 0x2
337	#define ICE_AQ_VSI_PVLAN_MODE_ALL 0x3	337	#define ICE_AQ_VSI_VLAN_MODE_ALL 0x3
338	#define ICE_AQ_VSI_PVLAN_INSERT_PVID BIT(2)	338	#define ICE_AQ_VSI_PVLAN_INSERT_PVID BIT(2)
339	#define ICE_AQ_VSI_PVLAN_EMOD_S 3	339	#define ICE_AQ_VSI_VLAN_EMOD_S 3
340	#define ICE_AQ_VSI_PVLAN_EMOD_M (0x3 << ICE_AQ_VSI_PVLAN_EMOD_S)	340	#define ICE_AQ_VSI_VLAN_EMOD_M (0x3 << ICE_AQ_VSI_VLAN_EMOD_S)
341	#define ICE_AQ_VSI_PVLAN_EMOD_STR_BOTH (0x0 << ICE_AQ_VSI_PVLAN_EMOD_S)	341	#define ICE_AQ_VSI_VLAN_EMOD_STR_BOTH (0x0 << ICE_AQ_VSI_VLAN_EMOD_S)
342	#define ICE_AQ_VSI_PVLAN_EMOD_STR_UP (0x1 << ICE_AQ_VSI_PVLAN_EMOD_S)	342	#define ICE_AQ_VSI_VLAN_EMOD_STR_UP (0x1 << ICE_AQ_VSI_VLAN_EMOD_S)
343	#define ICE_AQ_VSI_PVLAN_EMOD_STR (0x2 << ICE_AQ_VSI_PVLAN_EMOD_S)	343	#define ICE_AQ_VSI_VLAN_EMOD_STR (0x2 << ICE_AQ_VSI_VLAN_EMOD_S)
344	#define ICE_AQ_VSI_PVLAN_EMOD_NOTHING (0x3 << ICE_AQ_VSI_PVLAN_EMOD_S)	344	#define ICE_AQ_VSI_VLAN_EMOD_NOTHING (0x3 << ICE_AQ_VSI_VLAN_EMOD_S)
345	u8 pvlan_reserved2[3];	345	u8 pvlan_reserved2[3];
346	/* ingress egress up sections */	346	/* ingress egress up sections */
347	__le32 ingress_table; /* bitmap, 3 bits per up */	347	__le32 ingress_table; /* bitmap, 3 bits per up */
@@ -594,6 +594,7 @@ struct ice_sw_rule_lg_act { · 246 unmodified lines
594	#define ICE_LG_ACT_GENERIC_OFFSET_M (0x7 << ICE_LG_ACT_GENERIC_OFFSET_S)	594	#define ICE_LG_ACT_GENERIC_OFFSET_M (0x7 << ICE_LG_ACT_GENERIC_OFFSET_S)
595	#define ICE_LG_ACT_GENERIC_PRIORITY_S 22	595	#define ICE_LG_ACT_GENERIC_PRIORITY_S 22
596	#define ICE_LG_ACT_GENERIC_PRIORITY_M (0x7 << ICE_LG_ACT_GENERIC_PRIORITY_S)	596	#define ICE_LG_ACT_GENERIC_PRIORITY_M (0x7 << ICE_LG_ACT_GENERIC_PRIORITY_S)
		597	#define ICE_LG_ACT_GENERIC_OFF_RX_DESC_PROF_IDX 7
597		598
598	/* Action = 7 - Set Stat count */	599	/* Action = 7 - Set Stat count */
599	#define ICE_LG_ACT_STAT_COUNT 0x7	600	#define ICE_LG_ACT_STAT_COUNT 0x7

drivers/net/ethernet/intel/ice/ice_common.c+18−12

 /**
  * ice_clear_pf_cfg - Clear PF configuration
  * @hw: pointer to the hardware structure
+ *
+ * Clears any existing PF configuration (VSIs, VSI lists, switch rules, port
+ * configuration, flow director filters, etc.).
  */
 enum ice_status ice_clear_pf_cfg(struct ice_hw *hw)
 {
 	struct ice_phy_info *phy_info;
 	enum ice_status status = 0;
-	if (!pi)
+	if (!pi || !link_up)
 		return ICE_ERR_PARAM;
 	phy_info = &pi->phy;
 	}
 	/* LUT size is only valid for Global and PF table types */
-	if (lut_size == ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_128) {
+	switch (lut_size) {
-		flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_128_FLAG <<
+	case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_128:
-			  ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
+		break;
-			 ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
+	case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_512:
-	} else if (lut_size == ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_512) {
 		flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_512_FLAG <<
 			  ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
 			 ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
-	} else if ((lut_size == ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K) &&
+		break;
-		   (lut_type == ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF)) {
+	case ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K:
-		flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K_FLAG <<
+		if (lut_type == ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF) {
-			  ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
+			flags |= (ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_2K_FLAG <<
-			 ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
+				  ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_S) &
-	} else {
+				 ICE_AQC_GSET_RSS_LUT_TABLE_SIZE_M;
+			break;
+		}
+		/* fall-through */
+	default:
 		status = ICE_ERR_PARAM;
 		goto ice_aq_get_set_rss_lut_exit;
 	}

drivers/net/ethernet/intel/ice/ice_controlq.c+20−9

 	return 0;
 init_ctrlq_free_rq:
-	ice_shutdown_rq(hw, cq);
+	if (cq->rq.head) {
-	ice_shutdown_sq(hw, cq);
+		ice_shutdown_rq(hw, cq);
-	mutex_destroy(&cq->sq_lock);
+		mutex_destroy(&cq->rq_lock);
-	mutex_destroy(&cq->rq_lock);
+	}
+	if (cq->sq.head) {
+		ice_shutdown_sq(hw, cq);
+		mutex_destroy(&cq->sq_lock);
+	}
 	return status;
 }
 		return;
 	}
-	ice_shutdown_sq(hw, cq);
+	if (cq->sq.head) {
-	ice_shutdown_rq(hw, cq);
+		ice_shutdown_sq(hw, cq);
-	mutex_destroy(&cq->sq_lock);
+		mutex_destroy(&cq->sq_lock);
-	mutex_destroy(&cq->rq_lock);
+	}
+	if (cq->rq.head) {
+		ice_shutdown_rq(hw, cq);
+		mutex_destroy(&cq->rq_lock);
+	}
 }
 /**
 clean_rq_elem_out:
 	/* Set pending if needed, unlock and return */
-	if (pending)
+	if (pending) {
+		/* re-read HW head to calculate actual pending messages */
+		ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask);
 		*pending = (u16)((ntc > ntu ? cq->rq.count : 0) + (ntu - ntc));
+	}
 clean_rq_elem_err:
 	mutex_unlock(&cq->rq_lock);

drivers/net/ethernet/intel/ice/ice_ethtool.c+39−13

 {
 	struct ice_netdev_priv *np = netdev_priv(netdev);
-	return ((np->vsi->num_txq + np->vsi->num_rxq) *
+	return ((np->vsi->alloc_txq + np->vsi->alloc_rxq) *
 		(sizeof(struct ice_q_stats) / sizeof(u64)));
 }
 			p += ETH_GSTRING_LEN;
 		}
-		ice_for_each_txq(vsi, i) {
+		ice_for_each_alloc_txq(vsi, i) {
 			snprintf(p, ETH_GSTRING_LEN,
 				 "tx-queue-%u.tx_packets", i);
 			p += ETH_GSTRING_LEN;
 			p += ETH_GSTRING_LEN;
 		}
-		ice_for_each_rxq(vsi, i) {
+		ice_for_each_alloc_rxq(vsi, i) {
 			snprintf(p, ETH_GSTRING_LEN,
 				 "rx-queue-%u.rx_packets", i);
 			p += ETH_GSTRING_LEN;
 {
 	switch (sset) {
 	case ETH_SS_STATS:
+		/* The number (and order) of strings reported *must* remain
+		 * constant for a given netdevice. This function must not
+		 * report a different number based on run time parameters
+		 * (such as the number of queues in use, or the setting of
+		 * a private ethtool flag). This is due to the nature of the
+		 * ethtool stats API.
+		 *
+		 * User space programs such as ethtool must make 3 separate
+		 * ioctl requests, one for size, one for the strings, and
+		 * finally one for the stats. Since these cross into
+		 * user space, changes to the number or size could result in
+		 * undefined memory access or incorrect string<->value
+		 * correlations for statistics.
+		 *
+		 * Even if it appears to be safe, changes to the size or
+		 * order of strings will suffer from race conditions and are
+		 * not safe.
+		 */
 		return ICE_ALL_STATS_LEN(netdev);
 	default:
 		return -EOPNOTSUPP;
 	/* populate per queue stats */
 	rcu_read_lock();
-	ice_for_each_txq(vsi, j) {
+	ice_for_each_alloc_txq(vsi, j) {
 		ring = READ_ONCE(vsi->tx_rings[j]);
-		if (!ring)
+		if (ring) {
-			continue;
+			data[i++] = ring->stats.pkts;
-		data[i++] = ring->stats.pkts;
+			data[i++] = ring->stats.bytes;
-		data[i++] = ring->stats.bytes;
+		} else {
+			data[i++] = 0;
+			data[i++] = 0;
+		}
 	}
-	ice_for_each_rxq(vsi, j) {
+	ice_for_each_alloc_rxq(vsi, j) {
 		ring = READ_ONCE(vsi->rx_rings[j]);
-		data[i++] = ring->stats.pkts;
+		if (ring) {
-		data[i++] = ring->stats.bytes;
+			data[i++] = ring->stats.pkts;
+			data[i++] = ring->stats.bytes;
+		} else {
+			data[i++] = 0;
+			data[i++] = 0;
+		}
 	}
 	rcu_read_unlock();
 		goto done;
 	}
-	for (i = 0; i < vsi->num_txq; i++) {
+	for (i = 0; i < vsi->alloc_txq; i++) {
 		/* clone ring and setup updated count */
 		tx_rings[i] = *vsi->tx_rings[i];
 		tx_rings[i].count = new_tx_cnt;
 		goto done;
 	}
-	for (i = 0; i < vsi->num_rxq; i++) {
+	for (i = 0; i < vsi->alloc_rxq; i++) {
 		/* clone ring and setup updated count */
 		rx_rings[i] = *vsi->rx_rings[i];
 		rx_rings[i].count = new_rx_cnt;

drivers/net/ethernet/intel/ice/ice_hw_autogen.h+0−8

 #define PFINT_FW_CTL_CAUSE_ENA_S	30
 #define PFINT_FW_CTL_CAUSE_ENA_M	BIT(PFINT_FW_CTL_CAUSE_ENA_S)
 #define PFINT_OICR			0x0016CA00
-#define PFINT_OICR_HLP_RDY_S		14
-#define PFINT_OICR_HLP_RDY_M		BIT(PFINT_OICR_HLP_RDY_S)
-#define PFINT_OICR_CPM_RDY_S		15
-#define PFINT_OICR_CPM_RDY_M		BIT(PFINT_OICR_CPM_RDY_S)
 #define PFINT_OICR_ECC_ERR_S		16
 #define PFINT_OICR_ECC_ERR_M		BIT(PFINT_OICR_ECC_ERR_S)
 #define PFINT_OICR_MAL_DETECT_S		19
 #define PFINT_OICR_GRST_M		BIT(PFINT_OICR_GRST_S)
 #define PFINT_OICR_PCI_EXCEPTION_S	21
 #define PFINT_OICR_PCI_EXCEPTION_M	BIT(PFINT_OICR_PCI_EXCEPTION_S)
-#define PFINT_OICR_GPIO_S		22
-#define PFINT_OICR_GPIO_M		BIT(PFINT_OICR_GPIO_S)
-#define PFINT_OICR_STORM_DETECT_S	24
-#define PFINT_OICR_STORM_DETECT_M	BIT(PFINT_OICR_STORM_DETECT_S)
 #define PFINT_OICR_HMC_ERR_S		26
 #define PFINT_OICR_HMC_ERR_M		BIT(PFINT_OICR_HMC_ERR_S)
 #define PFINT_OICR_PE_CRITERR_S		28

drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h+1−0

@@ -265,6 +265,7 @@ enum ice_rx_flex_desc_status_error_0_bits { · 264 unmodified lines
265	struct ice_rlan_ctx {	265	struct ice_rlan_ctx {
266	u16 head;	266	u16 head;
267	u16 cpuid; /* bigger than needed, see above for reason */	267	u16 cpuid; /* bigger than needed, see above for reason */
		268	#define ICE_RLAN_BASE_S 7
268	u64 base;	269	u64 base;
269	u16 qlen;	270	u16 qlen;
270	#define ICE_RLAN_CTX_DBUF_S 7	271	#define ICE_RLAN_CTX_DBUF_S 7

drivers/net/ethernet/intel/ice/ice_main.c+66−49

@@ -901,7 +901,7 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) · 900 unmodified lines
901	case ice_aqc_opc_get_link_status:	901	case ice_aqc_opc_get_link_status:
902	if (ice_handle_link_event(pf))	902	if (ice_handle_link_event(pf))
903	dev_err(&pf->pdev->dev,	903	dev_err(&pf->pdev->dev,
904	"Could not handle link event");	904	"Could not handle link event\n");
905	break;	905	break;
906	default:	906	default:
907	dev_dbg(&pf->pdev->dev,	907	dev_dbg(&pf->pdev->dev,
@@ -916,6 +916,21 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) · 8 unmodified lines
916	return pending && (i == ICE_DFLT_IRQ_WORK);	916	return pending && (i == ICE_DFLT_IRQ_WORK);
917	}	917	}
918		918
		919	/**
		920	* ice_ctrlq_pending - check if there is a difference between ntc and ntu
		921	* @hw: pointer to hardware info
		922	* @cq: control queue information
		923	*
		924	* returns true if there are pending messages in a queue, false if there aren't
		925	*/
		926	static bool ice_ctrlq_pending(struct ice_hw hw, struct ice_ctl_q_info cq)
		927	{
		928	u16 ntu;
		929
		930	ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask);
		931	return cq->rq.next_to_clean != ntu;
		932	}
		933
919	/**	934	/**
920	* ice_clean_adminq_subtask - clean the AdminQ rings	935	* ice_clean_adminq_subtask - clean the AdminQ rings
921	* @pf: board private structure	936	* @pf: board private structure
@@ -923,7 +938,6 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type) · 1 unmodified line
923	static void ice_clean_adminq_subtask(struct ice_pf *pf)	938	static void ice_clean_adminq_subtask(struct ice_pf *pf)
924	{	939	{
925	struct ice_hw *hw = &pf->hw;	940	struct ice_hw *hw = &pf->hw;
926	u32 val;
927		941
928	if (!test_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state))	942	if (!test_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state))
929	return;	943	return;
@@ -933,9 +947,13 @@ static void ice_clean_adminq_subtask(struct ice_pf *pf) · 3 unmodified lines
933		947
934	clear_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state);	948	clear_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state);
935		949
936	/* re-enable Admin queue interrupt causes */	950	/* There might be a situation where new messages arrive to a control
937	val = rd32(hw, PFINT_FW_CTL);	951	* queue between processing the last message and clearing the
938	wr32(hw, PFINT_FW_CTL, (val \| PFINT_FW_CTL_CAUSE_ENA_M));	952	* EVENT_PENDING bit. So before exiting, check queue head again (using
		953	* ice_ctrlq_pending) and process new messages if any.
		954	*/
		955	if (ice_ctrlq_pending(hw, &hw->adminq))
		956	__ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN);
939		957
940	ice_flush(hw);	958	ice_flush(hw);
941	}	959	}
@@ -1295,11 +1313,8 @@ static void ice_vsi_setup_q_map(struct ice_vsi vsi, struct ice_vsi_ctx ctxt) · 353 unmodified lines
1295	qcount = numq_tc;	1313	qcount = numq_tc;
1296	}	1314	}
1297		1315
1298	/* find higher power-of-2 of qcount */	1316	/* find the (rounded up) power-of-2 of qcount */
1299	pow = ilog2(qcount);	1317	pow = order_base_2(qcount);
1300
1301	if (!is_power_of_2(qcount))
1302	pow++;
1303		1318
1304	for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {	1319	for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {
1305	if (!(vsi->tc_cfg.ena_tc & BIT(i))) {	1320	if (!(vsi->tc_cfg.ena_tc & BIT(i))) {
@@ -1352,14 +1367,15 @@ static void ice_set_dflt_vsi_ctx(struct ice_vsi_ctx *ctxt) · 46 unmodified lines
1352	ctxt->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE;	1367	ctxt->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE;
1353	/* Traffic from VSI can be sent to LAN */	1368	/* Traffic from VSI can be sent to LAN */
1354	ctxt->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;	1369	ctxt->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;
1355	/* Allow all packets untagged/tagged */	1370
1356	ctxt->info.port_vlan_flags = ((ICE_AQ_VSI_PVLAN_MODE_ALL &	1371	/* By default bits 3 and 4 in vlan_flags are 0's which results in legacy
1357	ICE_AQ_VSI_PVLAN_MODE_M) >>	1372	* behavior (show VLAN, DEI, and UP) in descriptor. Also, allow all
1358	ICE_AQ_VSI_PVLAN_MODE_S);	1373	* packets untagged/tagged.
1359	/* Show VLAN/UP from packets in Rx descriptors */	1374	*/
1360	ctxt->info.port_vlan_flags \|= ((ICE_AQ_VSI_PVLAN_EMOD_STR_BOTH &	1375	ctxt->info.vlan_flags = ((ICE_AQ_VSI_VLAN_MODE_ALL &
1361	ICE_AQ_VSI_PVLAN_EMOD_M) >>	1376	ICE_AQ_VSI_VLAN_MODE_M) >>
1362	ICE_AQ_VSI_PVLAN_EMOD_S);	1377	ICE_AQ_VSI_VLAN_MODE_S);
		1378
1363	/* Have 1:1 UP mapping for both ingress/egress tables */	1379	/* Have 1:1 UP mapping for both ingress/egress tables */
1364	table \|= ICE_UP_TABLE_TRANSLATE(0, 0);	1380	table \|= ICE_UP_TABLE_TRANSLATE(0, 0);
1365	table \|= ICE_UP_TABLE_TRANSLATE(1, 1);	1381	table \|= ICE_UP_TABLE_TRANSLATE(1, 1);
@@ -1688,15 +1704,12 @@ static void ice_ena_misc_vector(struct ice_pf *pf) · 322 unmodified lines
1688	wr32(hw, PFINT_OICR_ENA, 0); /* disable all */	1704	wr32(hw, PFINT_OICR_ENA, 0); /* disable all */
1689	rd32(hw, PFINT_OICR); /* read to clear */	1705	rd32(hw, PFINT_OICR); /* read to clear */
1690		1706
1691	val = (PFINT_OICR_HLP_RDY_M \|	1707	val = (PFINT_OICR_ECC_ERR_M \|
1692	PFINT_OICR_CPM_RDY_M \|
1693	PFINT_OICR_ECC_ERR_M \|
1694	PFINT_OICR_MAL_DETECT_M \|	1708	PFINT_OICR_MAL_DETECT_M \|
1695	PFINT_OICR_GRST_M \|	1709	PFINT_OICR_GRST_M \|
1696	PFINT_OICR_PCI_EXCEPTION_M \|	1710	PFINT_OICR_PCI_EXCEPTION_M \|
1697	PFINT_OICR_GPIO_M \|	1711	PFINT_OICR_HMC_ERR_M \|
1698	PFINT_OICR_STORM_DETECT_M \|	1712	PFINT_OICR_PE_CRITERR_M);
1699	PFINT_OICR_HMC_ERR_M);
1700		1713
1701	wr32(hw, PFINT_OICR_ENA, val);	1714	wr32(hw, PFINT_OICR_ENA, val);
1702		1715
@@ -2058,15 +2071,13 @@ static int ice_req_irq_msix_misc(struct ice_pf *pf) · 355 unmodified lines
2058	skip_req_irq:	2071	skip_req_irq:
2059	ice_ena_misc_vector(pf);	2072	ice_ena_misc_vector(pf);
2060		2073
2061	val = (pf->oicr_idx & PFINT_OICR_CTL_MSIX_INDX_M) \|	2074	val = ((pf->oicr_idx & PFINT_OICR_CTL_MSIX_INDX_M) \|
2062	(ICE_RX_ITR & PFINT_OICR_CTL_ITR_INDX_M) \|	2075	PFINT_OICR_CTL_CAUSE_ENA_M);
2063	PFINT_OICR_CTL_CAUSE_ENA_M;
2064	wr32(hw, PFINT_OICR_CTL, val);	2076	wr32(hw, PFINT_OICR_CTL, val);
2065		2077
2066	/* This enables Admin queue Interrupt causes */	2078	/* This enables Admin queue Interrupt causes */
2067	val = (pf->oicr_idx & PFINT_FW_CTL_MSIX_INDX_M) \|	2079	val = ((pf->oicr_idx & PFINT_FW_CTL_MSIX_INDX_M) \|
2068	(ICE_RX_ITR & PFINT_FW_CTL_ITR_INDX_M) \|	2080	PFINT_FW_CTL_CAUSE_ENA_M);
2069	PFINT_FW_CTL_CAUSE_ENA_M;
2070	wr32(hw, PFINT_FW_CTL, val);	2081	wr32(hw, PFINT_FW_CTL, val);
2071		2082
2072	itr_gran = hw->itr_gran_200;	2083	itr_gran = hw->itr_gran_200;
@@ -3246,8 +3257,10 @@ static void ice_clear_interrupt_scheme(struct ice_pf *pf) · 1173 unmodified lines
3246	if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))	3257	if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
3247	ice_dis_msix(pf);	3258	ice_dis_msix(pf);
3248		3259
3249	devm_kfree(&pf->pdev->dev, pf->irq_tracker);	3260	if (pf->irq_tracker) {
3250	pf->irq_tracker = NULL;	3261	devm_kfree(&pf->pdev->dev, pf->irq_tracker);
		3262	pf->irq_tracker = NULL;
		3263	}
3251	}	3264	}
3252		3265
3253	/**	3266	/**
@@ -3271,7 +3284,7 @@ static int ice_probe(struct pci_dev *pdev, · 17 unmodified lines
3271		3284
3272	err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), pci_name(pdev));	3285	err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), pci_name(pdev));
3273	if (err) {	3286	if (err) {
3274	dev_err(&pdev->dev, "I/O map error %d\n", err);	3287	dev_err(&pdev->dev, "BAR0 I/O map error %d\n", err);
3275	return err;	3288	return err;
3276	}	3289	}
3277		3290
@@ -3720,10 +3733,10 @@ static int ice_vsi_manage_vlan_insertion(struct ice_vsi *vsi) · 442 unmodified lines
3720	enum ice_status status;	3733	enum ice_status status;
3721		3734
3722	/* Here we are configuring the VSI to let the driver add VLAN tags by	3735	/* Here we are configuring the VSI to let the driver add VLAN tags by
3723	* setting port_vlan_flags to ICE_AQ_VSI_PVLAN_MODE_ALL. The actual VLAN	3736	* setting vlan_flags to ICE_AQ_VSI_VLAN_MODE_ALL. The actual VLAN tag
3724	* tag insertion happens in the Tx hot path, in ice_tx_map.	3737	* insertion happens in the Tx hot path, in ice_tx_map.
3725	*/	3738	*/
3726	ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_MODE_ALL;	3739	ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_ALL;
3727		3740
3728	ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);	3741	ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
3729	ctxt.vsi_num = vsi->vsi_num;	3742	ctxt.vsi_num = vsi->vsi_num;
@@ -3735,7 +3748,7 @@ static int ice_vsi_manage_vlan_insertion(struct ice_vsi *vsi) · 5 unmodified lines
3735	return -EIO;	3748	return -EIO;
3736	}	3749	}
3737		3750
3738	vsi->info.port_vlan_flags = ctxt.info.port_vlan_flags;	3751	vsi->info.vlan_flags = ctxt.info.vlan_flags;
3739	return 0;	3752	return 0;
3740	}	3753	}
3741		3754
@@ -3757,12 +3770,15 @@ static int ice_vsi_manage_vlan_stripping(struct ice_vsi *vsi, bool ena) · 15 unmodified lines
3757	*/	3770	*/
3758	if (ena) {	3771	if (ena) {
3759	/* Strip VLAN tag from Rx packet and put it in the desc */	3772	/* Strip VLAN tag from Rx packet and put it in the desc */
3760	ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_EMOD_STR_BOTH;	3773	ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_EMOD_STR_BOTH;
3761	} else {	3774	} else {
3762	/* Disable stripping. Leave tag in packet */	3775	/* Disable stripping. Leave tag in packet */
3763	ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_EMOD_NOTHING;	3776	ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_EMOD_NOTHING;
3764	}	3777	}
3765		3778
		3779	/* Allow all packets untagged/tagged */
		3780	ctxt.info.vlan_flags \|= ICE_AQ_VSI_VLAN_MODE_ALL;
		3781
3766	ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);	3782	ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
3767	ctxt.vsi_num = vsi->vsi_num;	3783	ctxt.vsi_num = vsi->vsi_num;
3768		3784
@@ -3773,7 +3789,7 @@ static int ice_vsi_manage_vlan_stripping(struct ice_vsi *vsi, bool ena) · 4 unmodified lines
3773	return -EIO;	3789	return -EIO;
3774	}	3790	}
3775		3791
3776	vsi->info.port_vlan_flags = ctxt.info.port_vlan_flags;	3792	vsi->info.vlan_flags = ctxt.info.vlan_flags;
3777	return 0;	3793	return 0;
3778	}	3794	}
3779		3795
@@ -3986,7 +4002,7 @@ static int ice_setup_rx_ctx(struct ice_ring *ring) · 206 unmodified lines
3986	/* clear the context structure first */	4002	/* clear the context structure first */
3987	memset(&rlan_ctx, 0, sizeof(rlan_ctx));	4003	memset(&rlan_ctx, 0, sizeof(rlan_ctx));
3988		4004
3989	rlan_ctx.base = ring->dma >> 7;	4005	rlan_ctx.base = ring->dma >> ICE_RLAN_BASE_S;
3990		4006
3991	rlan_ctx.qlen = ring->count;	4007	rlan_ctx.qlen = ring->count;
3992		4008
@@ -4098,11 +4114,12 @@ static int ice_vsi_cfg(struct ice_vsi *vsi) · 105 unmodified lines
4098	{	4114	{
4099	int err;	4115	int err;
4100		4116
4101	ice_set_rx_mode(vsi->netdev);	4117	if (vsi->netdev) {
4102		4118	ice_set_rx_mode(vsi->netdev);
4103	err = ice_restore_vlan(vsi);	4119	err = ice_restore_vlan(vsi);
4104	if (err)	4120	if (err)
4105	return err;	4121	return err;
		4122	}
4106		4123
4107	err = ice_vsi_cfg_txqs(vsi);	4124	err = ice_vsi_cfg_txqs(vsi);
4108	if (!err)	4125	if (!err)
@@ -4868,7 +4885,7 @@ int ice_down(struct ice_vsi *vsi) · 759 unmodified lines
4868	*/	4885	*/
4869	static int ice_vsi_setup_tx_rings(struct ice_vsi *vsi)	4886	static int ice_vsi_setup_tx_rings(struct ice_vsi *vsi)
4870	{	4887	{
4871	int i, err;	4888	int i, err = 0;
4872		4889
4873	if (!vsi->num_txq) {	4890	if (!vsi->num_txq) {
4874	dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Tx queues\n",	4891	dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Tx queues\n",
@@ -4893,7 +4910,7 @@ static int ice_vsi_setup_tx_rings(struct ice_vsi *vsi) · 18 unmodified lines
4893	*/	4910	*/
4894	static int ice_vsi_setup_rx_rings(struct ice_vsi *vsi)	4911	static int ice_vsi_setup_rx_rings(struct ice_vsi *vsi)
4895	{	4912	{
4896	int i, err;	4913	int i, err = 0;
4897		4914
4898	if (!vsi->num_rxq) {	4915	if (!vsi->num_rxq) {
4899	dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Rx queues\n",	4916	dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Rx queues\n",
@@ -5235,7 +5252,7 @@ static int ice_change_mtu(struct net_device *netdev, int new_mtu) · 335 unmodified lines
5235	u8 count = 0;	5252	u8 count = 0;
5236		5253
5237	if (new_mtu == netdev->mtu) {	5254	if (new_mtu == netdev->mtu) {
5238	netdev_warn(netdev, "mtu is already %d\n", netdev->mtu);	5255	netdev_warn(netdev, "mtu is already %u\n", netdev->mtu);
5239	return 0;	5256	return 0;
5240	}	5257	}
5241		5258

drivers/net/ethernet/intel/ice/ice_nvm.c+2−3

  *
  * This function will request NVM ownership.
  */
-static enum
+static enum ice_status
-ice_status ice_acquire_nvm(struct ice_hw *hw,
+ice_acquire_nvm(struct ice_hw *hw, enum ice_aq_res_access_type access)
-			   enum ice_aq_res_access_type access)
 {
 	if (hw->nvm.blank_nvm_mode)
 		return 0;

drivers/net/ethernet/intel/ice/ice_sched.c+1−2

@@ -1576,8 +1576,7 @@ ice_sched_update_vsi_child_nodes(struct ice_port_info *pi, u16 vsi_id, u8 tc, · 1575 unmodified lines
1576	return status;	1576	return status;
1577	}	1577	}
1578		1578
1579	if (owner == ICE_SCHED_NODE_OWNER_LAN)	1579	vsi->max_lanq[tc] = new_numqs;
1580	vsi->max_lanq[tc] = new_numqs;
1581		1580
1582	return status;	1581	return status;
1583	}	1582	}

drivers/net/ethernet/intel/ice/ice_switch.c+2−2

 	act |= (1 << ICE_LG_ACT_GENERIC_VALUE_S) & ICE_LG_ACT_GENERIC_VALUE_M;
 	lg_act->pdata.lg_act.act[1] = cpu_to_le32(act);
-	act = (7 << ICE_LG_ACT_GENERIC_OFFSET_S) & ICE_LG_ACT_GENERIC_VALUE_M;
+	act = (ICE_LG_ACT_GENERIC_OFF_RX_DESC_PROF_IDX <<
+	       ICE_LG_ACT_GENERIC_OFFSET_S) & ICE_LG_ACT_GENERIC_OFFSET_M;
 	/* Third action Marker value */
 	act |= ICE_LG_ACT_GENERIC;
 	act |= (sw_marker << ICE_LG_ACT_GENERIC_VALUE_S) &
 		ICE_LG_ACT_GENERIC_VALUE_M;
-	act |= (0 << ICE_LG_ACT_GENERIC_OFFSET_S) & ICE_LG_ACT_GENERIC_VALUE_M;
 	lg_act->pdata.lg_act.act[2] = cpu_to_le32(act);
 	/* call the fill switch rule to fill the lookup tx rx structure */

drivers/net/ethernet/intel/ice/ice_switch.h+3−3

@@ -17,7 +17,7 @@ struct ice_vsi_ctx { · 16 unmodified lines
17	u16 vsis_unallocated;	17	u16 vsis_unallocated;
18	u16 flags;	18	u16 flags;
19	struct ice_aqc_vsi_props info;	19	struct ice_aqc_vsi_props info;
20	bool alloc_from_pool;	20	u8 alloc_from_pool;
21	};	21	};
22		22
23	enum ice_sw_fwd_act_type {	23	enum ice_sw_fwd_act_type {
@@ -94,8 +94,8 @@ struct ice_fltr_info { · 70 unmodified lines
94	u8 qgrp_size;	94	u8 qgrp_size;
95		95
96	/* Rule creations populate these indicators basing on the switch type */	96	/* Rule creations populate these indicators basing on the switch type */
97	bool lb_en; /* Indicate if packet can be looped back */	97	u8 lb_en; /* Indicate if packet can be looped back */
98	bool lan_en; /* Indicate if packet can be forwarded to the uplink */	98	u8 lan_en; /* Indicate if packet can be forwarded to the uplink */
99	};	99	};
100		100
101	/* Bookkeeping structure to hold bitmap of VSIs corresponding to VSI list id */	101	/* Bookkeeping structure to hold bitmap of VSIs corresponding to VSI list id */

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

@@ -143,7 +143,7 @@ struct ice_ring { · 142 unmodified lines
143	u16 next_to_use;	143	u16 next_to_use;
144	u16 next_to_clean;	144	u16 next_to_clean;
145		145
146	bool ring_active; /* is ring online or not */	146	u8 ring_active; /* is ring online or not */
147		147
148	/* stats structs */	148	/* stats structs */
149	struct ice_q_stats stats;	149	struct ice_q_stats stats;

drivers/net/ethernet/intel/ice/ice_type.h+8−8

@@ -83,7 +83,7 @@ struct ice_link_status { · 82 unmodified lines
83	u64 phy_type_low;	83	u64 phy_type_low;
84	u16 max_frame_size;	84	u16 max_frame_size;
85	u16 link_speed;	85	u16 link_speed;
86	bool lse_ena; /* Link Status Event notification */	86	u8 lse_ena; /* Link Status Event notification */
87	u8 link_info;	87	u8 link_info;
88	u8 an_info;	88	u8 an_info;
89	u8 ext_info;	89	u8 ext_info;
@@ -101,7 +101,7 @@ struct ice_phy_info { · 11 unmodified lines
101	struct ice_link_status link_info_old;	101	struct ice_link_status link_info_old;
102	u64 phy_type_low;	102	u64 phy_type_low;
103	enum ice_media_type media_type;	103	enum ice_media_type media_type;
104	bool get_link_info;	104	u8 get_link_info;
105	};	105	};
106		106
107	/* Common HW capabilities for SW use */	107	/* Common HW capabilities for SW use */
@@ -167,7 +167,7 @@ struct ice_nvm_info { · 59 unmodified lines
167	u32 oem_ver; /* OEM version info */	167	u32 oem_ver; /* OEM version info */
168	u16 sr_words; /* Shadow RAM size in words */	168	u16 sr_words; /* Shadow RAM size in words */
169	u16 ver; /* NVM package version */	169	u16 ver; /* NVM package version */
170	bool blank_nvm_mode; /* is NVM empty (no FW present) */	170	u8 blank_nvm_mode; /* is NVM empty (no FW present) */
171	};	171	};
172		172
173	/* Max number of port to queue branches w.r.t topology */	173	/* Max number of port to queue branches w.r.t topology */
@@ -181,7 +181,7 @@ struct ice_sched_node { · 7 unmodified lines
181	struct ice_aqc_txsched_elem_data info;	181	struct ice_aqc_txsched_elem_data info;
182	u32 agg_id; /* aggregator group id */	182	u32 agg_id; /* aggregator group id */
183	u16 vsi_id;	183	u16 vsi_id;
184	bool in_use; /* suspended or in use */	184	u8 in_use; /* suspended or in use */
185	u8 tx_sched_layer; /* Logical Layer (1-9) */	185	u8 tx_sched_layer; /* Logical Layer (1-9) */
186	u8 num_children;	186	u8 num_children;
187	u8 tc_num;	187	u8 tc_num;
@@ -218,7 +218,7 @@ struct ice_sched_vsi_info { · 30 unmodified lines
218	struct ice_sched_tx_policy {	218	struct ice_sched_tx_policy {
219	u16 max_num_vsis;	219	u16 max_num_vsis;
220	u8 max_num_lan_qs_per_tc[ICE_MAX_TRAFFIC_CLASS];	220	u8 max_num_lan_qs_per_tc[ICE_MAX_TRAFFIC_CLASS];
221	bool rdma_ena;	221	u8 rdma_ena;
222	};	222	};
223		223
224	struct ice_port_info {	224	struct ice_port_info {
@@ -243,7 +243,7 @@ struct ice_port_info { · 18 unmodified lines
243	struct list_head agg_list; /* lists all aggregator */	243	struct list_head agg_list; /* lists all aggregator */
244	u8 lport;	244	u8 lport;
245	#define ICE_LPORT_MASK 0xff	245	#define ICE_LPORT_MASK 0xff
246	bool is_vf;	246	u8 is_vf;
247	};	247	};
248		248
249	struct ice_switch_info {	249	struct ice_switch_info {
@@ -287,7 +287,7 @@ struct ice_hw { · 37 unmodified lines
287	u8 max_cgds;	287	u8 max_cgds;
288	u8 sw_entry_point_layer;	288	u8 sw_entry_point_layer;
289		289
290	bool evb_veb; /* true for VEB, false for VEPA */	290	u8 evb_veb; /* true for VEB, false for VEPA */
291	struct ice_bus_info bus;	291	struct ice_bus_info bus;
292	struct ice_nvm_info nvm;	292	struct ice_nvm_info nvm;
293	struct ice_hw_dev_caps dev_caps; /* device capabilities */	293	struct ice_hw_dev_caps dev_caps; /* device capabilities */
@@ -318,7 +318,7 @@ struct ice_hw { · 24 unmodified lines
318	u8 itr_gran_100;	318	u8 itr_gran_100;
319	u8 itr_gran_50;	319	u8 itr_gran_50;
320	u8 itr_gran_25;	320	u8 itr_gran_25;
321	bool ucast_shared; /* true if VSIs can share unicast addr */	321	u8 ucast_shared; /* true if VSIs can share unicast addr */
322		322
323	};	323	};
324		324

drivers/net/ethernet/intel/igb/igb_ethtool.c+1−1

@@ -1649,7 +1649,7 @@ static int igb_integrated_phy_loopback(struct igb_adapter *adapter) · 1648 unmodified lines
1649	if (hw->phy.type == e1000_phy_m88)	1649	if (hw->phy.type == e1000_phy_m88)
1650	igb_phy_disable_receiver(adapter);	1650	igb_phy_disable_receiver(adapter);
1651		1651
1652	mdelay(500);	1652	msleep(500);
1653	return 0;	1653	return 0;
1654	}	1654	}
1655		1655

drivers/net/ethernet/intel/igb/igb_main.c+4−3

 	adapter->mac_table = kcalloc(hw->mac.rar_entry_count,
 				     sizeof(struct igb_mac_addr),
-				     GFP_ATOMIC);
+				     GFP_KERNEL);
 	if (!adapter->mac_table)
 		return -ENOMEM;
 	/* Setup and initialize a copy of the hw vlan table array */
 	adapter->shadow_vfta = kcalloc(E1000_VLAN_FILTER_TBL_SIZE, sizeof(u32),
-				       GFP_ATOMIC);
+				       GFP_KERNEL);
 	if (!adapter->shadow_vfta)
 		return -ENOMEM;
 	if (skb->ip_summed != CHECKSUM_PARTIAL) {
 csum_failed:
-		if (!(first->tx_flags & IGB_TX_FLAGS_VLAN))
+		if (!(first->tx_flags & IGB_TX_FLAGS_VLAN) &&
+		    !tx_ring->launchtime_enable)
 			return;
 		goto no_csum;
 	}

drivers/net/ethernet/intel/ixgb/ixgb_main.c+2−3

 	rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
 	rxdr->size = ALIGN(rxdr->size, 4096);
-	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+	rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
-					GFP_KERNEL);
+					 GFP_KERNEL);
 	if (!rxdr->desc) {
 		vfree(rxdr->buffer_info);
 		return -ENOMEM;
 	}
-	memset(rxdr->desc, 0, rxdr->size);
 	rxdr->next_to_clean = 0;
 	rxdr->next_to_use = 0;

drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c+2−2

@@ -192,7 +192,7 @@ static int ixgbe_fcoe_ddp_setup(struct net_device *netdev, u16 xid, · 191 unmodified lines
192	}	192	}
193		193
194	/* alloc the udl from per cpu ddp pool */	194	/* alloc the udl from per cpu ddp pool */
195	ddp->udl = dma_pool_alloc(ddp_pool->pool, GFP_ATOMIC, &ddp->udp);	195	ddp->udl = dma_pool_alloc(ddp_pool->pool, GFP_KERNEL, &ddp->udp);
196	if (!ddp->udl) {	196	if (!ddp->udl) {
197	e_err(drv, "failed allocated ddp context\n");	197	e_err(drv, "failed allocated ddp context\n");
198	goto out_noddp_unmap;	198	goto out_noddp_unmap;
@@ -760,7 +760,7 @@ int ixgbe_setup_fcoe_ddp_resources(struct ixgbe_adapter *adapter) · 561 unmodified lines
760	return 0;	760	return 0;
761		761
762	/* Extra buffer to be shared by all DDPs for HW work around */	762	/* Extra buffer to be shared by all DDPs for HW work around */
763	buffer = kmalloc(IXGBE_FCBUFF_MIN, GFP_ATOMIC);	763	buffer = kmalloc(IXGBE_FCBUFF_MIN, GFP_KERNEL);
764	if (!buffer)	764	if (!buffer)
765	return -ENOMEM;	765	return -ENOMEM;
766		766

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c+29−7

 	adapter->mac_table = kcalloc(hw->mac.num_rar_entries,
 				     sizeof(struct ixgbe_mac_addr),
-				     GFP_ATOMIC);
+				     GFP_KERNEL);
 	if (!adapter->mac_table)
 		return -ENOMEM;
 	struct ixgbe_adapter *adapter = netdev_priv(netdev);
 	if (adapter->xdp_prog) {
-		e_warn(probe, "MTU cannot be changed while XDP program is loaded\n");
+		int new_frame_size = new_mtu + ETH_HLEN + ETH_FCS_LEN +
-		return -EPERM;
+				     VLAN_HLEN;
+		int i;
+		for (i = 0; i < adapter->num_rx_queues; i++) {
+			struct ixgbe_ring *ring = adapter->rx_ring[i];
+			if (new_frame_size > ixgbe_rx_bufsz(ring)) {
+				e_warn(probe, "Requested MTU size is not supported with XDP\n");
+				return -EINVAL;
+			}
+		}
 	}
 	/*
 #ifdef CONFIG_IXGBE_DCB
 	if (tc) {
+		if (adapter->xdp_prog) {
+			e_warn(probe, "DCB is not supported with XDP\n");
+			ixgbe_init_interrupt_scheme(adapter);
+			if (netif_running(dev))
+				ixgbe_open(dev);
+			return -EINVAL;
+		}
 		netdev_set_num_tc(dev, tc);
 		ixgbe_set_prio_tc_map(adapter);
 			    struct tcf_exts *exts, u64 *action, u8 *queue)
 {
 	const struct tc_action *a;
-	LIST_HEAD(actions);
+	int i;
 	if (!tcf_exts_has_actions(exts))
 		return -EINVAL;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		/* Drop action */
 		if (is_tcf_gact_shot(a)) {
 			*action = IXGBE_FDIR_DROP_QUEUE;
 	int tcs = adapter->hw_tcs ? : 1;
 	int pool, err;
+	if (adapter->xdp_prog) {
+		e_warn(probe, "L2FW offload is not supported with XDP\n");
+		return ERR_PTR(-EINVAL);
+	}
 	/* The hardware supported by ixgbe only filters on the destination MAC
 	 * address. In order to avoid issues we only support offloading modes
 	 * where the hardware can actually provide the functionality.

drivers/net/ethernet/intel/ixgbe/ixgbe_sriov.c+31−0

@@ -53,6 +53,11 @@ static int __ixgbe_enable_sriov(struct ixgbe_adapter *adapter, · 52 unmodified lines
53	struct ixgbe_hw *hw = &adapter->hw;	53	struct ixgbe_hw *hw = &adapter->hw;
54	int i;	54	int i;
55		55
		56	if (adapter->xdp_prog) {
		57	e_warn(probe, "SRIOV is not supported with XDP\n");
		58	return -EINVAL;
		59	}
		60
56	/* Enable VMDq flag so device will be set in VM mode */	61	/* Enable VMDq flag so device will be set in VM mode */
57	adapter->flags \|= IXGBE_FLAG_SRIOV_ENABLED \|	62	adapter->flags \|= IXGBE_FLAG_SRIOV_ENABLED \|
58	IXGBE_FLAG_VMDQ_ENABLED;	63	IXGBE_FLAG_VMDQ_ENABLED;
@@ -688,8 +693,13 @@ static int ixgbe_set_vf_macvlan(struct ixgbe_adapter *adapter, · 629 unmodified lines
688	static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)	693	static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf)
689	{	694	{
690	struct ixgbe_hw *hw = &adapter->hw;	695	struct ixgbe_hw *hw = &adapter->hw;
		696	struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ];
691	struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];	697	struct vf_data_storage *vfinfo = &adapter->vfinfo[vf];
		698	u32 q_per_pool = __ALIGN_MASK(1, ~vmdq->mask);
692	u8 num_tcs = adapter->hw_tcs;	699	u8 num_tcs = adapter->hw_tcs;
		700	u32 reg_val;
		701	u32 queue;
		702	u32 word;
693		703
694	/* remove VLAN filters beloning to this VF */	704	/* remove VLAN filters beloning to this VF */
695	ixgbe_clear_vf_vlans(adapter, vf);	705	ixgbe_clear_vf_vlans(adapter, vf);
@@ -726,6 +736,27 @@ static inline void ixgbe_vf_reset_event(struct ixgbe_adapter *adapter, u32 vf) · 30 unmodified lines
726		736
727	/* reset VF api back to unknown */	737	/* reset VF api back to unknown */
728	adapter->vfinfo[vf].vf_api = ixgbe_mbox_api_10;	738	adapter->vfinfo[vf].vf_api = ixgbe_mbox_api_10;
		739
		740	/* Restart each queue for given VF */
		741	for (queue = 0; queue < q_per_pool; queue++) {
		742	unsigned int reg_idx = (vf * q_per_pool) + queue;
		743
		744	reg_val = IXGBE_READ_REG(hw, IXGBE_PVFTXDCTL(reg_idx));
		745
		746	/* Re-enabling only configured queues */
		747	if (reg_val) {
		748	reg_val \|= IXGBE_TXDCTL_ENABLE;
		749	IXGBE_WRITE_REG(hw, IXGBE_PVFTXDCTL(reg_idx), reg_val);
		750	reg_val &= ~IXGBE_TXDCTL_ENABLE;
		751	IXGBE_WRITE_REG(hw, IXGBE_PVFTXDCTL(reg_idx), reg_val);
		752	}
		753	}
		754
		755	/* Clear VF's mailbox memory */
		756	for (word = 0; word < IXGBE_VFMAILBOX_SIZE; word++)
		757	IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf), word, 0);
		758
		759	IXGBE_WRITE_FLUSH(hw);
729	}	760	}
730		761
731	static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,	762	static int ixgbe_set_vf_mac(struct ixgbe_adapter *adapter,

drivers/net/ethernet/intel/ixgbe/ixgbe_type.h+1−0

@@ -2518,6 +2518,7 @@ enum { · 2517 unmodified lines
2518	/* Translated register #defines */	2518	/* Translated register #defines */
2519	#define IXGBE_PVFTDH(P) (0x06010 + (0x40 * (P)))	2519	#define IXGBE_PVFTDH(P) (0x06010 + (0x40 * (P)))
2520	#define IXGBE_PVFTDT(P) (0x06018 + (0x40 * (P)))	2520	#define IXGBE_PVFTDT(P) (0x06018 + (0x40 * (P)))
		2521	#define IXGBE_PVFTXDCTL(P) (0x06028 + (0x40 * (P)))
2521	#define IXGBE_PVFTDWBAL(P) (0x06038 + (0x40 * (P)))	2522	#define IXGBE_PVFTDWBAL(P) (0x06038 + (0x40 * (P)))
2522	#define IXGBE_PVFTDWBAH(P) (0x0603C + (0x40 * (P)))	2523	#define IXGBE_PVFTDWBAH(P) (0x0603C + (0x40 * (P)))
2523		2524

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

 		goto out_ok;
 	modify_ip_header = false;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
+		int k;
 		if (!is_tcf_pedit(a))
 			continue;
 		nkeys = tcf_pedit_nkeys(a);
-		for (i = 0; i < nkeys; i++) {
+		for (k = 0; k < nkeys; k++) {
-			htype = tcf_pedit_htype(a, i);
+			htype = tcf_pedit_htype(a, k);
 			if (htype == TCA_PEDIT_KEY_EX_HDR_TYPE_IP4 ||
 			    htype == TCA_PEDIT_KEY_EX_HDR_TYPE_IP6) {
 				modify_ip_header = true;
 	const struct tc_action *a;
 	LIST_HEAD(actions);
 	u32 action = 0;
-	int err;
+	int err, i;
 	if (!tcf_exts_has_actions(exts))
 		return -EINVAL;
 	attr->flow_tag = MLX5_FS_DEFAULT_FLOW_TAG;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		if (is_tcf_gact_shot(a)) {
 			action |= MLX5_FLOW_CONTEXT_ACTION_DROP;
 			if (MLX5_CAP_FLOWTABLE(priv->mdev,
 	LIST_HEAD(actions);
 	bool encap = false;
 	u32 action = 0;
-	int err;
+	int err, i;
 	if (!tcf_exts_has_actions(exts))
 		return -EINVAL;
 	attr->in_rep = rpriv->rep;
 	attr->in_mdev = priv->mdev;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		if (is_tcf_gact_shot(a)) {
 			action |= MLX5_FLOW_CONTEXT_ACTION_DROP |
 				  MLX5_FLOW_CONTEXT_ACTION_COUNT;

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

@@ -1346,8 +1346,7 @@ static int mlxsw_sp_port_add_cls_matchall(struct mlxsw_sp_port *mlxsw_sp_port, · 1345 unmodified lines
1346	return -ENOMEM;	1346	return -ENOMEM;
1347	mall_tc_entry->cookie = f->cookie;	1347	mall_tc_entry->cookie = f->cookie;
1348		1348
1349	tcf_exts_to_list(f->exts, &actions);	1349	a = tcf_exts_first_action(f->exts);
1350	a = list_first_entry(&actions, struct tc_action, list);
1351		1350
1352	if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {	1351	if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {
1353	struct mlxsw_sp_port_mall_mirror_tc_entry *mirror;	1352	struct mlxsw_sp_port_mall_mirror_tc_entry *mirror;

drivers/net/ethernet/mellanox/mlxsw/spectrum.h+2−0

@@ -414,6 +414,8 @@ mlxsw_sp_netdevice_ipip_ul_event(struct mlxsw_sp *mlxsw_sp, · 413 unmodified lines
414	void	414	void
415	mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan);	415	mlxsw_sp_port_vlan_router_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan);
416	void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif);	416	void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif);
		417	void mlxsw_sp_rif_destroy_by_dev(struct mlxsw_sp *mlxsw_sp,
		418	struct net_device *dev);
417		419
418	/* spectrum_kvdl.c */	420	/* spectrum_kvdl.c */
419	enum mlxsw_sp_kvdl_entry_type {	421	enum mlxsw_sp_kvdl_entry_type {

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c+2−4

 					 struct netlink_ext_ack *extack)
 {
 	const struct tc_action *a;
-	LIST_HEAD(actions);
+	int err, i;
-	int err;
 	if (!tcf_exts_has_actions(exts))
 		return 0;
 	if (err)
 		return err;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		if (is_tcf_gact_ok(a)) {
 			err = mlxsw_sp_acl_rulei_act_terminate(rulei);
 			if (err) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+11−0

@@ -6234,6 +6234,17 @@ void mlxsw_sp_rif_destroy(struct mlxsw_sp_rif *rif) · 6233 unmodified lines
6234	mlxsw_sp_vr_put(mlxsw_sp, vr);	6234	mlxsw_sp_vr_put(mlxsw_sp, vr);
6235	}	6235	}
6236		6236
		6237	void mlxsw_sp_rif_destroy_by_dev(struct mlxsw_sp *mlxsw_sp,
		6238	struct net_device *dev)
		6239	{
		6240	struct mlxsw_sp_rif *rif;
		6241
		6242	rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, dev);
		6243	if (!rif)
		6244	return;
		6245	mlxsw_sp_rif_destroy(rif);
		6246	}
		6247
6237	static void	6248	static void
6238	mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,	6249	mlxsw_sp_rif_subport_params_init(struct mlxsw_sp_rif_params *params,
6239	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)	6250	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c+20−0

@@ -127,6 +127,24 @@ bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp, · 126 unmodified lines
127	return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);	127	return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
128	}	128	}
129		129
		130	static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
		131	void *data)
		132	{
		133	struct mlxsw_sp *mlxsw_sp = data;
		134
		135	mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
		136	return 0;
		137	}
		138
		139	static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
		140	struct net_device *dev)
		141	{
		142	mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
		143	netdev_walk_all_upper_dev_rcu(dev,
		144	mlxsw_sp_bridge_device_upper_rif_destroy,
		145	mlxsw_sp);
		146	}
		147
130	static struct mlxsw_sp_bridge_device *	148	static struct mlxsw_sp_bridge_device *
131	mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,	149	mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
132	struct net_device *br_dev)	150	struct net_device *br_dev)
@@ -165,6 +183,8 @@ static void · 32 unmodified lines
165	mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,	183	mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
166	struct mlxsw_sp_bridge_device *bridge_device)	184	struct mlxsw_sp_bridge_device *bridge_device)
167	{	185	{
		186	mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
		187	bridge_device->dev);
168	list_del(&bridge_device->list);	188	list_del(&bridge_device->list);
169	if (bridge_device->vlan_enabled)	189	if (bridge_device->vlan_enabled)
170	bridge->vlan_enabled_exists = false;	190	bridge->vlan_enabled_exists = false;

drivers/net/ethernet/netronome/nfp/flower/action.c+2−4

 			      struct net_device *netdev,
 			      struct nfp_fl_payload *nfp_flow)
 {
-	int act_len, act_cnt, err, tun_out_cnt, out_cnt;
+	int act_len, act_cnt, err, tun_out_cnt, out_cnt, i;
 	enum nfp_flower_tun_type tun_type;
 	const struct tc_action *a;
 	u32 csum_updated = 0;
-	LIST_HEAD(actions);
 	memset(nfp_flow->action_data, 0, NFP_FL_MAX_A_SIZ);
 	nfp_flow->meta.act_len = 0;
 	tun_out_cnt = 0;
 	out_cnt = 0;
-	tcf_exts_to_list(flow->exts, &actions);
+	tcf_exts_for_each_action(i, a, flow->exts) {
-	list_for_each_entry(a, &actions, list) {
 		err = nfp_flower_loop_action(app, a, flow, nfp_flow, &act_len,
 					     netdev, &tun_type, &tun_out_cnt,
 					     &out_cnt, &csum_updated);

drivers/net/ethernet/qlogic/qed/qed_init_ops.c+1−1

@@ -407,7 +407,7 @@ static void qed_init_cmd_rd(struct qed_hwfn *p_hwfn, · 406 unmodified lines
407		407
408	if (i == QED_INIT_MAX_POLL_COUNT) {	408	if (i == QED_INIT_MAX_POLL_COUNT) {
409	DP_ERR(p_hwfn,	409	DP_ERR(p_hwfn,
410	"Timeout when polling reg: 0x%08x [ Waiting-for: %08x Got: %08x (comparsion %08x)]\n",	410	"Timeout when polling reg: 0x%08x [ Waiting-for: %08x Got: %08x (comparison %08x)]\n",
411	addr, le32_to_cpu(cmd->expected_val),	411	addr, le32_to_cpu(cmd->expected_val),
412	val, le32_to_cpu(cmd->op_data));	412	val, le32_to_cpu(cmd->op_data));
413	}	413	}

drivers/net/ethernet/qlogic/qed/qed_mcp.c+158−29

@@ -48,7 +48,7 @@ · 47 unmodified lines
48	#include "qed_reg_addr.h"	48	#include "qed_reg_addr.h"
49	#include "qed_sriov.h"	49	#include "qed_sriov.h"
50		50
51	#define CHIP_MCP_RESP_ITER_US 10	51	#define QED_MCP_RESP_ITER_US 10
52		52
53	#define QED_DRV_MB_MAX_RETRIES (500 * 1000) /* Account for 5 sec */	53	#define QED_DRV_MB_MAX_RETRIES (500 * 1000) /* Account for 5 sec */
54	#define QED_MCP_RESET_RETRIES (50 * 1000) /* Account for 500 msec */	54	#define QED_MCP_RESET_RETRIES (50 * 1000) /* Account for 500 msec */
@@ -183,18 +183,57 @@ int qed_mcp_free(struct qed_hwfn *p_hwfn) · 128 unmodified lines
183	return 0;	183	return 0;
184	}	184	}
185		185
		186	/* Maximum of 1 sec to wait for the SHMEM ready indication */
		187	#define QED_MCP_SHMEM_RDY_MAX_RETRIES 20
		188	#define QED_MCP_SHMEM_RDY_ITER_MS 50
		189
186	static int qed_load_mcp_offsets(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	190	static int qed_load_mcp_offsets(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
187	{	191	{
188	struct qed_mcp_info *p_info = p_hwfn->mcp_info;	192	struct qed_mcp_info *p_info = p_hwfn->mcp_info;
		193	u8 cnt = QED_MCP_SHMEM_RDY_MAX_RETRIES;
		194	u8 msec = QED_MCP_SHMEM_RDY_ITER_MS;
189	u32 drv_mb_offsize, mfw_mb_offsize;	195	u32 drv_mb_offsize, mfw_mb_offsize;
190	u32 mcp_pf_id = MCP_PF_ID(p_hwfn);	196	u32 mcp_pf_id = MCP_PF_ID(p_hwfn);
191		197
192	p_info->public_base = qed_rd(p_hwfn, p_ptt, MISC_REG_SHARED_MEM_ADDR);	198	p_info->public_base = qed_rd(p_hwfn, p_ptt, MISC_REG_SHARED_MEM_ADDR);
193	if (!p_info->public_base)	199	if (!p_info->public_base) {
194	return 0;	200	DP_NOTICE(p_hwfn,
		201	"The address of the MCP scratch-pad is not configured\n");
		202	return -EINVAL;
		203	}
195		204
196	p_info->public_base \|= GRCBASE_MCP;	205	p_info->public_base \|= GRCBASE_MCP;
197		206
		207	/* Get the MFW MB address and number of supported messages */
		208	mfw_mb_offsize = qed_rd(p_hwfn, p_ptt,
		209	SECTION_OFFSIZE_ADDR(p_info->public_base,
		210	PUBLIC_MFW_MB));
		211	p_info->mfw_mb_addr = SECTION_ADDR(mfw_mb_offsize, mcp_pf_id);
		212	p_info->mfw_mb_length = (u16)qed_rd(p_hwfn, p_ptt,
		213	p_info->mfw_mb_addr +
		214	offsetof(struct public_mfw_mb,
		215	sup_msgs));
		216
		217	/* The driver can notify that there was an MCP reset, and might read the
		218	* SHMEM values before the MFW has completed initializing them.
		219	* To avoid this, the "sup_msgs" field in the MFW mailbox is used as a
		220	* data ready indication.
		221	*/
		222	while (!p_info->mfw_mb_length && --cnt) {
		223	msleep(msec);
		224	p_info->mfw_mb_length =
		225	(u16)qed_rd(p_hwfn, p_ptt,
		226	p_info->mfw_mb_addr +
		227	offsetof(struct public_mfw_mb, sup_msgs));
		228	}
		229
		230	if (!cnt) {
		231	DP_NOTICE(p_hwfn,
		232	"Failed to get the SHMEM ready notification after %d msec\n",
		233	QED_MCP_SHMEM_RDY_MAX_RETRIES * msec);
		234	return -EBUSY;
		235	}
		236
198	/* Calculate the driver and MFW mailbox address */	237	/* Calculate the driver and MFW mailbox address */
199	drv_mb_offsize = qed_rd(p_hwfn, p_ptt,	238	drv_mb_offsize = qed_rd(p_hwfn, p_ptt,
200	SECTION_OFFSIZE_ADDR(p_info->public_base,	239	SECTION_OFFSIZE_ADDR(p_info->public_base,
@@ -204,13 +243,6 @@ static int qed_load_mcp_offsets(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt) · 3 unmodified lines
204	"drv_mb_offsiz = 0x%x, drv_mb_addr = 0x%x mcp_pf_id = 0x%x\n",	243	"drv_mb_offsiz = 0x%x, drv_mb_addr = 0x%x mcp_pf_id = 0x%x\n",
205	drv_mb_offsize, p_info->drv_mb_addr, mcp_pf_id);	244	drv_mb_offsize, p_info->drv_mb_addr, mcp_pf_id);
206		245
207	/* Set the MFW MB address */
208	mfw_mb_offsize = qed_rd(p_hwfn, p_ptt,
209	SECTION_OFFSIZE_ADDR(p_info->public_base,
210	PUBLIC_MFW_MB));
211	p_info->mfw_mb_addr = SECTION_ADDR(mfw_mb_offsize, mcp_pf_id);
212	p_info->mfw_mb_length = (u16)qed_rd(p_hwfn, p_ptt, p_info->mfw_mb_addr);
213
214	/* Get the current driver mailbox sequence before sending	246	/* Get the current driver mailbox sequence before sending
215	* the first command	247	* the first command
216	*/	248	*/
@@ -285,9 +317,15 @@ static void qed_mcp_reread_offsets(struct qed_hwfn *p_hwfn, · 68 unmodified lines
285		317
286	int qed_mcp_reset(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	318	int qed_mcp_reset(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
287	{	319	{
288	u32 org_mcp_reset_seq, seq, delay = CHIP_MCP_RESP_ITER_US, cnt = 0;	320	u32 org_mcp_reset_seq, seq, delay = QED_MCP_RESP_ITER_US, cnt = 0;
289	int rc = 0;	321	int rc = 0;
290		322
		323	if (p_hwfn->mcp_info->b_block_cmd) {
		324	DP_NOTICE(p_hwfn,
		325	"The MFW is not responsive. Avoid sending MCP_RESET mailbox command.\n");
		326	return -EBUSY;
		327	}
		328
291	/* Ensure that only a single thread is accessing the mailbox */	329	/* Ensure that only a single thread is accessing the mailbox */
292	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);	330	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);
293		331
@@ -413,14 +451,41 @@ static void __qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 119 unmodified lines
413	(p_mb_params->cmd \| seq_num), p_mb_params->param);	451	(p_mb_params->cmd \| seq_num), p_mb_params->param);
414	}	452	}
415		453
		454	static void qed_mcp_cmd_set_blocking(struct qed_hwfn *p_hwfn, bool block_cmd)
		455	{
		456	p_hwfn->mcp_info->b_block_cmd = block_cmd;
		457
		458	DP_INFO(p_hwfn, "%s sending of mailbox commands to the MFW\n",
		459	block_cmd ? "Block" : "Unblock");
		460	}
		461
		462	static void qed_mcp_print_cpu_info(struct qed_hwfn *p_hwfn,
		463	struct qed_ptt *p_ptt)
		464	{
		465	u32 cpu_mode, cpu_state, cpu_pc_0, cpu_pc_1, cpu_pc_2;
		466	u32 delay = QED_MCP_RESP_ITER_US;
		467
		468	cpu_mode = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
		469	cpu_state = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_STATE);
		470	cpu_pc_0 = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_PROGRAM_COUNTER);
		471	udelay(delay);
		472	cpu_pc_1 = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_PROGRAM_COUNTER);
		473	udelay(delay);
		474	cpu_pc_2 = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_PROGRAM_COUNTER);
		475
		476	DP_NOTICE(p_hwfn,
		477	"MCP CPU info: mode 0x%08x, state 0x%08x, pc {0x%08x, 0x%08x, 0x%08x}\n",
		478	cpu_mode, cpu_state, cpu_pc_0, cpu_pc_1, cpu_pc_2);
		479	}
		480
416	static int	481	static int
417	_qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn,	482	_qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn,
418	struct qed_ptt *p_ptt,	483	struct qed_ptt *p_ptt,
419	struct qed_mcp_mb_params *p_mb_params,	484	struct qed_mcp_mb_params *p_mb_params,
420	u32 max_retries, u32 delay)	485	u32 max_retries, u32 usecs)
421	{	486	{
		487	u32 cnt = 0, msecs = DIV_ROUND_UP(usecs, 1000);
422	struct qed_mcp_cmd_elem *p_cmd_elem;	488	struct qed_mcp_cmd_elem *p_cmd_elem;
423	u32 cnt = 0;
424	u16 seq_num;	489	u16 seq_num;
425	int rc = 0;	490	int rc = 0;
426		491
@@ -443,7 +508,11 @@ _qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 16 unmodified lines
443	goto err;	508	goto err;
444		509
445	spin_unlock_bh(&p_hwfn->mcp_info->cmd_lock);	510	spin_unlock_bh(&p_hwfn->mcp_info->cmd_lock);
446	udelay(delay);	511
		512	if (QED_MB_FLAGS_IS_SET(p_mb_params, CAN_SLEEP))
		513	msleep(msecs);
		514	else
		515	udelay(usecs);
447	} while (++cnt < max_retries);	516	} while (++cnt < max_retries);
448		517
449	if (cnt >= max_retries) {	518	if (cnt >= max_retries) {
@@ -472,7 +541,11 @@ _qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 22 unmodified lines
472	* The spinlock stays locked until the list element is removed.	541	* The spinlock stays locked until the list element is removed.
473	*/	542	*/
474		543
475	udelay(delay);	544	if (QED_MB_FLAGS_IS_SET(p_mb_params, CAN_SLEEP))
		545	msleep(msecs);
		546	else
		547	udelay(usecs);
		548
476	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);	549	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);
477		550
478	if (p_cmd_elem->b_is_completed)	551	if (p_cmd_elem->b_is_completed)
@@ -491,11 +564,15 @@ _qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 12 unmodified lines
491	DP_NOTICE(p_hwfn,	564	DP_NOTICE(p_hwfn,
492	"The MFW failed to respond to command 0x%08x [param 0x%08x].\n",	565	"The MFW failed to respond to command 0x%08x [param 0x%08x].\n",
493	p_mb_params->cmd, p_mb_params->param);	566	p_mb_params->cmd, p_mb_params->param);
		567	qed_mcp_print_cpu_info(p_hwfn, p_ptt);
494		568
495	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);	569	spin_lock_bh(&p_hwfn->mcp_info->cmd_lock);
496	qed_mcp_cmd_del_elem(p_hwfn, p_cmd_elem);	570	qed_mcp_cmd_del_elem(p_hwfn, p_cmd_elem);
497	spin_unlock_bh(&p_hwfn->mcp_info->cmd_lock);	571	spin_unlock_bh(&p_hwfn->mcp_info->cmd_lock);
498		572
		573	if (!QED_MB_FLAGS_IS_SET(p_mb_params, AVOID_BLOCK))
		574	qed_mcp_cmd_set_blocking(p_hwfn, true);
		575
499	return -EAGAIN;	576	return -EAGAIN;
500	}	577	}
501		578
@@ -507,7 +584,7 @@ _qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 5 unmodified lines
507	"MFW mailbox: response 0x%08x param 0x%08x [after %d.%03d ms]\n",	584	"MFW mailbox: response 0x%08x param 0x%08x [after %d.%03d ms]\n",
508	p_mb_params->mcp_resp,	585	p_mb_params->mcp_resp,
509	p_mb_params->mcp_param,	586	p_mb_params->mcp_param,
510	(cnt * delay) / 1000, (cnt * delay) % 1000);	587	(cnt * usecs) / 1000, (cnt * usecs) % 1000);
511		588
512	/* Clear the sequence number from the MFW response */	589	/* Clear the sequence number from the MFW response */
513	p_mb_params->mcp_resp &= FW_MSG_CODE_MASK;	590	p_mb_params->mcp_resp &= FW_MSG_CODE_MASK;
@@ -525,7 +602,7 @@ static int qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 11 unmodified lines
525	{	602	{
526	size_t union_data_size = sizeof(union drv_union_data);	603	size_t union_data_size = sizeof(union drv_union_data);
527	u32 max_retries = QED_DRV_MB_MAX_RETRIES;	604	u32 max_retries = QED_DRV_MB_MAX_RETRIES;
528	u32 delay = CHIP_MCP_RESP_ITER_US;	605	u32 usecs = QED_MCP_RESP_ITER_US;
529		606
530	/* MCP not initialized */	607	/* MCP not initialized */
531	if (!qed_mcp_is_init(p_hwfn)) {	608	if (!qed_mcp_is_init(p_hwfn)) {
@@ -533,6 +610,13 @@ static int qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 1 unmodified line
533	return -EBUSY;	610	return -EBUSY;
534	}	611	}
535		612
		613	if (p_hwfn->mcp_info->b_block_cmd) {
		614	DP_NOTICE(p_hwfn,
		615	"The MFW is not responsive. Avoid sending mailbox command 0x%08x [param 0x%08x].\n",
		616	p_mb_params->cmd, p_mb_params->param);
		617	return -EBUSY;
		618	}
		619
536	if (p_mb_params->data_src_size > union_data_size \|\|	620	if (p_mb_params->data_src_size > union_data_size \|\|
537	p_mb_params->data_dst_size > union_data_size) {	621	p_mb_params->data_dst_size > union_data_size) {
538	DP_ERR(p_hwfn,	622	DP_ERR(p_hwfn,
@@ -542,8 +626,13 @@ static int qed_mcp_cmd_and_union(struct qed_hwfn *p_hwfn, · 3 unmodified lines
542	return -EINVAL;	626	return -EINVAL;
543	}	627	}
544		628
		629	if (QED_MB_FLAGS_IS_SET(p_mb_params, CAN_SLEEP)) {
		630	max_retries = DIV_ROUND_UP(max_retries, 1000);
		631	usecs *= 1000;
		632	}
		633
545	return _qed_mcp_cmd_and_union(p_hwfn, p_ptt, p_mb_params, max_retries,	634	return _qed_mcp_cmd_and_union(p_hwfn, p_ptt, p_mb_params, max_retries,
546	delay);	635	usecs);
547	}	636	}
548		637
549	int qed_mcp_cmd(struct qed_hwfn *p_hwfn,	638	int qed_mcp_cmd(struct qed_hwfn *p_hwfn,
@@ -761,6 +850,7 @@ __qed_mcp_load_req(struct qed_hwfn *p_hwfn, · 211 unmodified lines
761	mb_params.data_src_size = sizeof(load_req);	850	mb_params.data_src_size = sizeof(load_req);
762	mb_params.p_data_dst = &load_rsp;	851	mb_params.p_data_dst = &load_rsp;
763	mb_params.data_dst_size = sizeof(load_rsp);	852	mb_params.data_dst_size = sizeof(load_rsp);
		853	mb_params.flags = QED_MB_FLAG_CAN_SLEEP \| QED_MB_FLAG_AVOID_BLOCK;
764		854
765	DP_VERBOSE(p_hwfn, QED_MSG_SP,	855	DP_VERBOSE(p_hwfn, QED_MSG_SP,
766	"Load Request: param 0x%08x [init_hw %d, drv_type %d, hsi_ver %d, pda 0x%04x]\n",	856	"Load Request: param 0x%08x [init_hw %d, drv_type %d, hsi_ver %d, pda 0x%04x]\n",
@@ -982,7 +1072,8 @@ int qed_mcp_load_req(struct qed_hwfn *p_hwfn, · 215 unmodified lines
982		1072
983	int qed_mcp_unload_req(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	1073	int qed_mcp_unload_req(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
984	{	1074	{
985	u32 wol_param, mcp_resp, mcp_param;	1075	struct qed_mcp_mb_params mb_params;
		1076	u32 wol_param;
986		1077
987	switch (p_hwfn->cdev->wol_config) {	1078	switch (p_hwfn->cdev->wol_config) {
988	case QED_OV_WOL_DISABLED:	1079	case QED_OV_WOL_DISABLED:
@@ -1000,8 +1091,12 @@ int qed_mcp_unload_req(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt) · 11 unmodified lines
1000	wol_param = DRV_MB_PARAM_UNLOAD_WOL_MCP;	1091	wol_param = DRV_MB_PARAM_UNLOAD_WOL_MCP;
1001	}	1092	}
1002		1093
1003	return qed_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_UNLOAD_REQ, wol_param,	1094	memset(&mb_params, 0, sizeof(mb_params));
1004	&mcp_resp, &mcp_param);	1095	mb_params.cmd = DRV_MSG_CODE_UNLOAD_REQ;
		1096	mb_params.param = wol_param;
		1097	mb_params.flags = QED_MB_FLAG_CAN_SLEEP \| QED_MB_FLAG_AVOID_BLOCK;
		1098
		1099	return qed_mcp_cmd_and_union(p_hwfn, p_ptt, &mb_params);
1005	}	1100	}
1006		1101
1007	int qed_mcp_unload_done(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	1102	int qed_mcp_unload_done(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
@@ -2077,31 +2172,65 @@ qed_mcp_send_drv_version(struct qed_hwfn *p_hwfn, · 1069 unmodified lines
2077	return rc;	2172	return rc;
2078	}	2173	}
2079		2174
		2175	/* A maximal 100 msec waiting time for the MCP to halt */
		2176	#define QED_MCP_HALT_SLEEP_MS 10
		2177	#define QED_MCP_HALT_MAX_RETRIES 10
		2178
2080	int qed_mcp_halt(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	2179	int qed_mcp_halt(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
2081	{	2180	{
2082	u32 resp = 0, param = 0;	2181	u32 resp = 0, param = 0, cpu_state, cnt = 0;
2083	int rc;	2182	int rc;
2084		2183
2085	rc = qed_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MCP_HALT, 0, &resp,	2184	rc = qed_mcp_cmd(p_hwfn, p_ptt, DRV_MSG_CODE_MCP_HALT, 0, &resp,
2086	&param);	2185	&param);
2087	if (rc)	2186	if (rc) {
2088	DP_ERR(p_hwfn, "MCP response failure, aborting\n");	2187	DP_ERR(p_hwfn, "MCP response failure, aborting\n");
		2188	return rc;
		2189	}
2089		2190
2090	return rc;	2191	do {
		2192	msleep(QED_MCP_HALT_SLEEP_MS);
		2193	cpu_state = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_STATE);
		2194	if (cpu_state & MCP_REG_CPU_STATE_SOFT_HALTED)
		2195	break;
		2196	} while (++cnt < QED_MCP_HALT_MAX_RETRIES);
		2197
		2198	if (cnt == QED_MCP_HALT_MAX_RETRIES) {
		2199	DP_NOTICE(p_hwfn,
		2200	"Failed to halt the MCP [CPU_MODE = 0x%08x, CPU_STATE = 0x%08x]\n",
		2201	qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE), cpu_state);
		2202	return -EBUSY;
		2203	}
		2204
		2205	qed_mcp_cmd_set_blocking(p_hwfn, true);
		2206
		2207	return 0;
2091	}	2208	}
2092		2209
		2210	#define QED_MCP_RESUME_SLEEP_MS 10
		2211
2093	int qed_mcp_resume(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)	2212	int qed_mcp_resume(struct qed_hwfn p_hwfn, struct qed_ptt p_ptt)
2094	{	2213	{
2095	u32 value, cpu_mode;	2214	u32 cpu_mode, cpu_state;
2096		2215
2097	qed_wr(p_hwfn, p_ptt, MCP_REG_CPU_STATE, 0xffffffff);	2216	qed_wr(p_hwfn, p_ptt, MCP_REG_CPU_STATE, 0xffffffff);
2098		2217
2099	value = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
2100	value &= ~MCP_REG_CPU_MODE_SOFT_HALT;
2101	qed_wr(p_hwfn, p_ptt, MCP_REG_CPU_MODE, value);
2102	cpu_mode = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);	2218	cpu_mode = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_MODE);
		2219	cpu_mode &= ~MCP_REG_CPU_MODE_SOFT_HALT;
		2220	qed_wr(p_hwfn, p_ptt, MCP_REG_CPU_MODE, cpu_mode);
		2221	msleep(QED_MCP_RESUME_SLEEP_MS);
		2222	cpu_state = qed_rd(p_hwfn, p_ptt, MCP_REG_CPU_STATE);
2103		2223
2104	return (cpu_mode & MCP_REG_CPU_MODE_SOFT_HALT) ? -EAGAIN : 0;	2224	if (cpu_state & MCP_REG_CPU_STATE_SOFT_HALTED) {
		2225	DP_NOTICE(p_hwfn,
		2226	"Failed to resume the MCP [CPU_MODE = 0x%08x, CPU_STATE = 0x%08x]\n",
		2227	cpu_mode, cpu_state);
		2228	return -EBUSY;
		2229	}
		2230
		2231	qed_mcp_cmd_set_blocking(p_hwfn, false);
		2232
		2233	return 0;
2105	}	2234	}
2106		2235
2107	int qed_mcp_ov_update_current_config(struct qed_hwfn *p_hwfn,	2236	int qed_mcp_ov_update_current_config(struct qed_hwfn *p_hwfn,

drivers/net/ethernet/qlogic/qed/qed_mcp.h+18−9

@@ -635,11 +635,14 @@ struct qed_mcp_info { · 634 unmodified lines
635	*/	635	*/
636	spinlock_t cmd_lock;	636	spinlock_t cmd_lock;
637		637
		638	/* Flag to indicate whether sending a MFW mailbox command is blocked */
		639	bool b_block_cmd;
		640
638	/* Spinlock used for syncing SW link-changes and link-changes	641	/* Spinlock used for syncing SW link-changes and link-changes
639	* originating from attention context.	642	* originating from attention context.
640	*/	643	*/
641	spinlock_t link_lock;	644	spinlock_t link_lock;
642	bool block_mb_sending;	645
643	u32 public_base;	646	u32 public_base;
644	u32 drv_mb_addr;	647	u32 drv_mb_addr;
645	u32 mfw_mb_addr;	648	u32 mfw_mb_addr;
@@ -660,14 +663,20 @@ struct qed_mcp_info { · 14 unmodified lines
660	};	663	};
661		664
662	struct qed_mcp_mb_params {	665	struct qed_mcp_mb_params {
663	u32 cmd;	666	u32 cmd;
664	u32 param;	667	u32 param;
665	void *p_data_src;	668	void *p_data_src;
666	u8 data_src_size;	669	void *p_data_dst;
667	void *p_data_dst;	670	u8 data_src_size;
668	u8 data_dst_size;	671	u8 data_dst_size;
669	u32 mcp_resp;	672	u32 mcp_resp;
670	u32 mcp_param;	673	u32 mcp_param;
		674	u32 flags;
		675	#define QED_MB_FLAG_CAN_SLEEP (0x1 << 0)
		676	#define QED_MB_FLAG_AVOID_BLOCK (0x1 << 1)
		677	#define QED_MB_FLAGS_IS_SET(params, flag) \
		678	({ typeof(params) __params = (params); \
		679	(__params && (__params->flags & QED_MB_FLAG_ ## flag)); })
671	};	680	};
672		681
673	struct qed_drv_tlv_hdr {	682	struct qed_drv_tlv_hdr {

drivers/net/ethernet/qlogic/qed/qed_reg_addr.h+2−0

 	0
 #define MCP_REG_CPU_STATE \
 	0xe05004UL
+#define MCP_REG_CPU_STATE_SOFT_HALTED	(0x1UL << 10)
 #define MCP_REG_CPU_EVENT_MASK \
 	0xe05008UL
+#define MCP_REG_CPU_PROGRAM_COUNTER	0xe0501cUL
 #define PGLUE_B_REG_PF_BAR0_SIZE \
 	0x2aae60UL
 #define PGLUE_B_REG_PF_BAR1_SIZE \

drivers/net/ethernet/qlogic/qede/qede_filter.c+2−4

 static int qede_parse_actions(struct qede_dev *edev,
 			      struct tcf_exts *exts)
 {
-	int rc = -EINVAL, num_act = 0;
+	int rc = -EINVAL, num_act = 0, i;
 	const struct tc_action *a;
 	bool is_drop = false;
-	LIST_HEAD(actions);
 	if (!tcf_exts_has_actions(exts)) {
 		DP_NOTICE(edev, "No tc actions received\n");
 		return rc;
 	}
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, a, exts) {
-	list_for_each_entry(a, &actions, list) {
 		num_act++;
 		if (is_tcf_gact_shot(a))

drivers/net/ethernet/qlogic/qlge/qlge_main.c+8−15

 	return status;
 }
-static netdev_features_t qlge_fix_features(struct net_device *ndev,
-	netdev_features_t features)
-{
-	int err;
-	/* Update the behavior of vlan accel in the adapter */
-	err = qlge_update_hw_vlan_features(ndev, features);
-	if (err)
-		return err;
-	return features;
-}
 static int qlge_set_features(struct net_device *ndev,
 	netdev_features_t features)
 {
 	netdev_features_t changed = ndev->features ^ features;
+	int err;
+	if (changed & NETIF_F_HW_VLAN_CTAG_RX) {
+		/* Update the behavior of vlan accel in the adapter */
+		err = qlge_update_hw_vlan_features(ndev, features);
+		if (err)
+			return err;
-	if (changed & NETIF_F_HW_VLAN_CTAG_RX)
 		qlge_vlan_mode(ndev, features);
+	}
 	return 0;
 }
 	.ndo_set_mac_address	= qlge_set_mac_address,
 	.ndo_validate_addr	= eth_validate_addr,
 	.ndo_tx_timeout		= qlge_tx_timeout,
-	.ndo_fix_features	= qlge_fix_features,
 	.ndo_set_features	= qlge_set_features,
 	.ndo_vlan_rx_add_vid	= qlge_vlan_rx_add_vid,
 	.ndo_vlan_rx_kill_vid	= qlge_vlan_rx_kill_vid,

drivers/net/ethernet/renesas/ravb.h+1−4

+/* SPDX-License-Identifier: GPL-2.0 */
 /* Renesas Ethernet AVB device driver
  *
  * Copyright (C) 2014-2015 Renesas Electronics Corporation
  * Copyright (C) 2015-2016 Cogent Embedded, Inc. <source@cogentembedded.com>
  *
  * Based on the SuperH Ethernet driver
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License version 2,
- * as published by the Free Software Foundation.
  */
 #ifndef __RAVB_H__

drivers/net/ethernet/renesas/ravb_main.c+1−4

+// SPDX-License-Identifier: GPL-2.0
 /* Renesas Ethernet AVB device driver
  *
  * Copyright (C) 2014-2015 Renesas Electronics Corporation
  * Copyright (C) 2015-2016 Cogent Embedded, Inc. <source@cogentembedded.com>
  *
  * Based on the SuperH Ethernet driver
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License version 2,
- * as published by the Free Software Foundation.
  */
 #include <linux/cache.h>

drivers/net/ethernet/renesas/sh_eth.c+1−12

@@ -1,3 +1,4 @@
		1	// SPDX-License-Identifier: GPL-2.0
1	/* SuperH Ethernet device driver	2	/* SuperH Ethernet device driver
2	*	3	*
3	* Copyright (C) 2014 Renesas Electronics Corporation	4	* Copyright (C) 2014 Renesas Electronics Corporation
@@ -5,18 +6,6 @@ · 1 unmodified line
5	* Copyright (C) 2008-2014 Renesas Solutions Corp.	6	* Copyright (C) 2008-2014 Renesas Solutions Corp.
6	* Copyright (C) 2013-2017 Cogent Embedded, Inc.	7	* Copyright (C) 2013-2017 Cogent Embedded, Inc.
7	* Copyright (C) 2014 Codethink Limited	8	* Copyright (C) 2014 Codethink Limited
8	*
9	* This program is free software; you can redistribute it and/or modify it
10	* under the terms and conditions of the GNU General Public License,
11	* version 2, as published by the Free Software Foundation.
12	*
13	* This program is distributed in the hope it will be useful, but WITHOUT
14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16	* more details.
17	*
18	* The full GNU General Public License is included in this distribution in
19	* the file called "COPYING".
20	*/	9	*/
21		10
22	#include <linux/module.h>	11	#include <linux/module.h>

drivers/net/ethernet/renesas/sh_eth.h+1−12

@@ -1,19 +1,8 @@
		1	/* SPDX-License-Identifier: GPL-2.0 */
1	/* SuperH Ethernet device driver	2	/* SuperH Ethernet device driver
2	*	3	*
3	* Copyright (C) 2006-2012 Nobuhiro Iwamatsu	4	* Copyright (C) 2006-2012 Nobuhiro Iwamatsu
4	* Copyright (C) 2008-2012 Renesas Solutions Corp.	5	* Copyright (C) 2008-2012 Renesas Solutions Corp.
5	*
6	* This program is free software; you can redistribute it and/or modify it
7	* under the terms and conditions of the GNU General Public License,
8	* version 2, as published by the Free Software Foundation.
9	*
10	* This program is distributed in the hope it will be useful, but WITHOUT
11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13	* more details.
14	*
15	* The full GNU General Public License is included in this distribution in
16	* the file called "COPYING".
17	*/	6	*/
18		7
19	#ifndef __SH_ETH_H__	8	#ifndef __SH_ETH_H__

drivers/net/ethernet/stmicro/stmmac/Kconfig+5−5

@@ -33,7 +33,7 @@ config DWMAC_DWC_QOS_ETH · 32 unmodified lines
33	select PHYLIB	33	select PHYLIB
34	select CRC32	34	select CRC32
35	select MII	35	select MII
36	depends on OF && COMMON_CLK && HAS_DMA	36	depends on OF && HAS_DMA
37	help	37	help
38	Support for chips using the snps,dwc-qos-ethernet.txt DT binding.	38	Support for chips using the snps,dwc-qos-ethernet.txt DT binding.
39		39
@@ -57,7 +57,7 @@ config DWMAC_ANARION · 17 unmodified lines
57	config DWMAC_IPQ806X	57	config DWMAC_IPQ806X
58	tristate "QCA IPQ806x DWMAC support"	58	tristate "QCA IPQ806x DWMAC support"
59	default ARCH_QCOM	59	default ARCH_QCOM
60	depends on OF && COMMON_CLK && (ARCH_QCOM \|\| COMPILE_TEST)	60	depends on OF && (ARCH_QCOM \|\| COMPILE_TEST)
61	select MFD_SYSCON	61	select MFD_SYSCON
62	help	62	help
63	Support for QCA IPQ806X DWMAC Ethernet.	63	Support for QCA IPQ806X DWMAC Ethernet.
@@ -100,7 +100,7 @@ config DWMAC_OXNAS · 36 unmodified lines
100	config DWMAC_ROCKCHIP	100	config DWMAC_ROCKCHIP
101	tristate "Rockchip dwmac support"	101	tristate "Rockchip dwmac support"
102	default ARCH_ROCKCHIP	102	default ARCH_ROCKCHIP
103	depends on OF && COMMON_CLK && (ARCH_ROCKCHIP \|\| COMPILE_TEST)	103	depends on OF && (ARCH_ROCKCHIP \|\| COMPILE_TEST)
104	select MFD_SYSCON	104	select MFD_SYSCON
105	help	105	help
106	Support for Ethernet controller on Rockchip RK3288 SoC.	106	Support for Ethernet controller on Rockchip RK3288 SoC.
@@ -123,7 +123,7 @@ config DWMAC_SOCFPGA · 16 unmodified lines
123	config DWMAC_STI	123	config DWMAC_STI
124	tristate "STi GMAC support"	124	tristate "STi GMAC support"
125	default ARCH_STI	125	default ARCH_STI
126	depends on OF && COMMON_CLK && (ARCH_STI \|\| COMPILE_TEST)	126	depends on OF && (ARCH_STI \|\| COMPILE_TEST)
127	select MFD_SYSCON	127	select MFD_SYSCON
128	---help---	128	---help---
129	Support for ethernet controller on STi SOCs.	129	Support for ethernet controller on STi SOCs.
@@ -147,7 +147,7 @@ config DWMAC_STM32 · 17 unmodified lines
147	config DWMAC_SUNXI	147	config DWMAC_SUNXI
148	tristate "Allwinner GMAC support"	148	tristate "Allwinner GMAC support"
149	default ARCH_SUNXI	149	default ARCH_SUNXI
150	depends on OF && COMMON_CLK && (ARCH_SUNXI \|\| COMPILE_TEST)	150	depends on OF && (ARCH_SUNXI \|\| COMPILE_TEST)
151	---help---	151	---help---
152	Support for Allwinner A20/A31 GMAC ethernet controllers.	152	Support for Allwinner A20/A31 GMAC ethernet controllers.
153		153

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c+2−3

 	struct stmmac_tc_entry *action_entry = entry;
 	const struct tc_action *act;
 	struct tcf_exts *exts;
-	LIST_HEAD(actions);
+	int i;
 	exts = cls->knode.exts;
 	if (!tcf_exts_has_actions(exts))
 	if (frag)
 		action_entry = frag;
-	tcf_exts_to_list(exts, &actions);
+	tcf_exts_for_each_action(i, act, exts) {
-	list_for_each_entry(act, &actions, list) {
 		/* Accept */
 		if (is_tcf_gact_ok(act)) {
 			action_entry->val.af = 1;

drivers/net/hyperv/netvsc_drv.c+5−0

 #include <linux/netdevice.h>
 #include <linux/inetdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/pci.h>
 #include <linux/skbuff.h>
 #include <linux/if_vlan.h>
 #include <linux/in.h>
 {
 	struct net_device *ndev;
 	struct net_device_context *net_device_ctx;
+	struct device *pdev = vf_netdev->dev.parent;
 	struct netvsc_device *netvsc_dev;
 	int ret;
 	if (vf_netdev->addr_len != ETH_ALEN)
 		return NOTIFY_DONE;
+	if (!pdev || !dev_is_pci(pdev) || dev_is_pf(pdev))
+		return NOTIFY_DONE;
 	/*
 	 * We will use the MAC address to locate the synthetic interface to
 	 * associate with the VF interface. If we don't find a matching

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

@@ -5217,8 +5217,8 @@ static int rtl8152_probe(struct usb_interface *intf, · 5216 unmodified lines
5217	netdev->hw_features &= ~NETIF_F_RXCSUM;	5217	netdev->hw_features &= ~NETIF_F_RXCSUM;
5218	}	5218	}
5219		5219
5220	if (le16_to_cpu(udev->descriptor.bcdDevice) == 0x3011 &&	5220	if (le16_to_cpu(udev->descriptor.bcdDevice) == 0x3011 && udev->serial &&
5221	udev->serial && !strcmp(udev->serial, "000001000000")) {	5221	(!strcmp(udev->serial, "000001000000") \|\| !strcmp(udev->serial, "000002000000"))) {
5222	dev_info(&udev->dev, "Dell TB16 Dock, disable RX aggregation");	5222	dev_info(&udev->dev, "Dell TB16 Dock, disable RX aggregation");
5223	set_bit(DELL_TB_RX_AGG_BUG, &tp->flags);	5223	set_bit(DELL_TB_RX_AGG_BUG, &tp->flags);
5224	}	5224	}

drivers/vhost/vhost.c+1−1

@@ -952,7 +952,7 @@ static void vhost_iotlb_notify_vq(struct vhost_dev *d, · 951 unmodified lines
952	list_for_each_entry_safe(node, n, &d->pending_list, node) {	952	list_for_each_entry_safe(node, n, &d->pending_list, node) {
953	struct vhost_iotlb_msg *vq_msg = &node->msg.iotlb;	953	struct vhost_iotlb_msg *vq_msg = &node->msg.iotlb;
954	if (msg->iova <= vq_msg->iova &&	954	if (msg->iova <= vq_msg->iova &&
955	msg->iova + msg->size - 1 > vq_msg->iova &&	955	msg->iova + msg->size - 1 >= vq_msg->iova &&
956	vq_msg->type == VHOST_IOTLB_MISS) {	956	vq_msg->type == VHOST_IOTLB_MISS) {
957	vhost_poll_queue(&node->vq->poll);	957	vhost_poll_queue(&node->vq->poll);
958	list_del(&node->node);	958	list_del(&node->node);

include/net/act_api.h+0−7

 	const struct tc_action_ops	*ops;
 	__u32				type; /* for backward compat(TCA_OLD_COMPAT) */
 	__u32				order;
-	struct list_head		list;
 	struct tcf_idrinfo		*idrinfo;
 	u32				tcfa_index;
 	refcount_t			tcfa_refcnt;
 	atomic_t			tcfa_bindcnt;
-	u32				tcfa_capab;
 	int				tcfa_action;
 	struct tcf_t			tcfa_tm;
 	struct gnet_stats_basic_packed	tcfa_bstats;
 #define tcf_index	common.tcfa_index
 #define tcf_refcnt	common.tcfa_refcnt
 #define tcf_bindcnt	common.tcfa_bindcnt
-#define tcf_capab	common.tcfa_capab
 #define tcf_action	common.tcfa_action
 #define tcf_tm		common.tcfa_tm
 #define tcf_bstats	common.tcfa_bstats
 	size_t  (*get_fill_size)(const struct tc_action *act);
 	struct net_device *(*get_dev)(const struct tc_action *a);
 	void	(*put_dev)(struct net_device *dev);
-	int     (*delete)(struct net *net, u32 index);
 };
 struct tc_action_net {
 		       const struct tc_action_ops *ops,
 		       struct netlink_ext_ack *extack);
 int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index);
-bool tcf_idr_check(struct tc_action_net *tn, u32 index, struct tc_action **a,
-		    int bind);
 int tcf_idr_create(struct tc_action_net *tn, u32 index, struct nlattr *est,
 		   struct tc_action **a, const struct tc_action_ops *ops,
 		   int bind, bool cpustats);
 void tcf_idr_cleanup(struct tc_action_net *tn, u32 index);
 int tcf_idr_check_alloc(struct tc_action_net *tn, u32 *index,
 			struct tc_action **a, int bind);
-int tcf_idr_delete_index(struct tc_action_net *tn, u32 index);
 int __tcf_idr_release(struct tc_action *a, bool bind, bool strict);
 static inline int tcf_idr_release(struct tc_action *a, bool bind)

include/net/pkt_cls.h+14−11

@@ -298,19 +298,13 @@ static inline void tcf_exts_put_net(struct tcf_exts *exts) · 297 unmodified lines
298	#endif	298	#endif
299	}	299	}
300		300
301	static inline void tcf_exts_to_list(const struct tcf_exts *exts,
302	struct list_head *actions)
303	{
304	#ifdef CONFIG_NET_CLS_ACT	301	#ifdef CONFIG_NET_CLS_ACT
305	int i;	302	#define tcf_exts_for_each_action(i, a, exts) \
306		303	for (i = 0; i < TCA_ACT_MAX_PRIO && ((a) = (exts)->actions[i]); i++)
307	for (i = 0; i < exts->nr_actions; i++) {	304	#else
308	struct tc_action *a = exts->actions[i];	305	#define tcf_exts_for_each_action(i, a, exts) \
309		306	for (; 0; (void)(i), (void)(a), (void)(exts))
310	list_add_tail(&a->list, actions);
311	}
312	#endif	307	#endif
313	}
314		308
315	static inline void	309	static inline void
316	tcf_exts_stats_update(const struct tcf_exts *exts,	310	tcf_exts_stats_update(const struct tcf_exts *exts,
@@ -361,6 +355,15 @@ static inline bool tcf_exts_has_one_action(struct tcf_exts *exts) · 44 unmodified lines
361	#endif	355	#endif
362	}	356	}
363		357
		358	static inline struct tc_action tcf_exts_first_action(struct tcf_exts exts)
		359	{
		360	#ifdef CONFIG_NET_CLS_ACT
		361	return exts->actions[0];
		362	#else
		363	return NULL;
		364	#endif
		365	}
		366
364	/**	367	/**
365	* tcf_exts_exec - execute tc filter extensions	368	* tcf_exts_exec - execute tc filter extensions
366	* @skb: socket buffer	369	* @skb: socket buffer

kernel/bpf/hashtab.c+13−10

 #include <linux/jhash.h>
 #include <linux/filter.h>
 #include <linux/rculist_nulls.h>
+#include <linux/random.h>
 #include <uapi/linux/btf.h>
 #include "percpu_freelist.h"
 #include "bpf_lru_list.h"
 	atomic_t count;	/* number of elements in this hashtable */
 	u32 n_buckets;	/* number of hash buckets */
 	u32 elem_size;	/* size of each element in bytes */
+	u32 hashrnd;
 };
 /* each htab element is struct htab_elem + key + value */
 	if (!htab->buckets)
 		goto free_htab;
+	htab->hashrnd = get_random_int();
 	for (i = 0; i < htab->n_buckets; i++) {
 		INIT_HLIST_NULLS_HEAD(&htab->buckets[i].head, i);
 		raw_spin_lock_init(&htab->buckets[i].lock);
 	return ERR_PTR(err);
 }
-static inline u32 htab_map_hash(const void *key, u32 key_len)
+static inline u32 htab_map_hash(const void *key, u32 key_len, u32 hashrnd)
 {
-	return jhash(key, key_len, 0);
+	return jhash(key, key_len, hashrnd);
 }
 static inline struct bucket *__select_bucket(struct bpf_htab *htab, u32 hash)
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	head = select_bucket(htab, hash);
 	if (!key)
 		goto find_first_elem;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	head = select_bucket(htab, hash);
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;
 	key_size = map->key_size;
-	hash = htab_map_hash(key, key_size);
+	hash = htab_map_hash(key, key_size, htab->hashrnd);
 	b = __select_bucket(htab, hash);
 	head = &b->head;

kernel/bpf/sockmap.c+9−2

 static void smap_write_space(struct sock *sk)
 {
 	struct smap_psock *psock;
+	void (*write_space)(struct sock *sk);
 	rcu_read_lock();
 	psock = smap_psock_sk(sk);
 	if (likely(psock && test_bit(SMAP_TX_RUNNING, &psock->state)))
 		schedule_work(&psock->tx_work);
+	write_space = psock->save_write_space;
 	rcu_read_unlock();
+	write_space(sk);
 }
 static void smap_stop_sock(struct smap_psock *psock, struct sock *sk)
 		return ERR_PTR(-EPERM);
 	/* check sanity of attributes */
-	if (attr->max_entries == 0 || attr->value_size != 4 ||
+	if (attr->max_entries == 0 ||
+	    attr->key_size == 0 ||
+	    attr->value_size != 4 ||
 	    attr->map_flags & ~SOCK_CREATE_FLAG_MASK)
 		return ERR_PTR(-EINVAL);
 	}
 	l_new = kmalloc_node(htab->elem_size, GFP_ATOMIC | __GFP_NOWARN,
 			     htab->map.numa_node);
-	if (!l_new)
+	if (!l_new) {
+		atomic_dec(&htab->count);
 		return ERR_PTR(-ENOMEM);
+	}
 	memcpy(l_new->key, key, key_size);
 	l_new->sk = sk;

lib/rhashtable.c+0−1

@@ -28,7 +28,6 @@ · 27 unmodified lines
28	#include <linux/rhashtable.h>	28	#include <linux/rhashtable.h>
29	#include <linux/err.h>	29	#include <linux/err.h>
30	#include <linux/export.h>	30	#include <linux/export.h>
31	#include <linux/rhashtable.h>
32		31
33	#define HASH_DEFAULT_SIZE 64UL	32	#define HASH_DEFAULT_SIZE 64UL
34	#define HASH_MIN_SIZE 4U	33	#define HASH_MIN_SIZE 4U

net/dsa/slave.c+1−3

 	const struct tc_action *a;
 	struct dsa_port *to_dp;
 	int err = -EOPNOTSUPP;
-	LIST_HEAD(actions);
 	if (!ds->ops->port_mirror_add)
 		return err;
 	if (!tcf_exts_has_one_action(cls->exts))
 		return err;
-	tcf_exts_to_list(cls->exts, &actions);
+	a = tcf_exts_first_action(cls->exts);
-	a = list_first_entry(&actions, struct tc_action, list);
 	if (is_tcf_mirred_egress_mirror(a) && protocol == htons(ETH_P_ALL)) {
 		struct dsa_mall_mirror_tc_entry *mirror;

net/ipv4/tcp_bbr.c+24−18

 	u32     mode:3,		     /* current bbr_mode in state machine */
 		prev_ca_state:3,     /* CA state on previous ACK */
 		packet_conservation:1,  /* use packet conservation? */
-		restore_cwnd:1,	     /* decided to revert cwnd to old value */
 		round_start:1,	     /* start of packet-timed tx->ack round? */
 		idle_restart:1,	     /* restarting after idle? */
 		probe_rtt_round_done:1,  /* a BBR_PROBE_RTT round at 4 pkts? */
-		unused:12,
+		unused:13,
 		lt_is_sampling:1,    /* taking long-term ("LT") samples now? */
 		lt_rtt_cnt:7,	     /* round trips in long-term interval */
 		lt_use_bw:1;	     /* use lt_bw as our bw estimate? */
 /* If we estimate we're policed, use lt_bw for this many round trips: */
 static const u32 bbr_lt_bw_max_rtts = 48;
+static void bbr_check_probe_rtt_done(struct sock *sk);
 /* Do we estimate that STARTUP filled the pipe? */
 static bool bbr_full_bw_reached(const struct sock *sk)
 {
 		 */
 		if (bbr->mode == BBR_PROBE_BW)
 			bbr_set_pacing_rate(sk, bbr_bw(sk), BBR_UNIT);
+		else if (bbr->mode == BBR_PROBE_RTT)
+			bbr_check_probe_rtt_done(sk);
 	}
 }
 		cwnd = tcp_packets_in_flight(tp) + acked;
 	} else if (prev_state >= TCP_CA_Recovery && state < TCP_CA_Recovery) {
 		/* Exiting loss recovery; restore cwnd saved before recovery. */
-		bbr->restore_cwnd = 1;
+		cwnd = max(cwnd, bbr->prior_cwnd);
 		bbr->packet_conservation = 0;
 	}
 	bbr->prev_ca_state = state;
-	if (bbr->restore_cwnd) {
-		/* Restore cwnd after exiting loss recovery or PROBE_RTT. */
-		cwnd = max(cwnd, bbr->prior_cwnd);
-		bbr->restore_cwnd = 0;
-	}
 	if (bbr->packet_conservation) {
 		*new_cwnd = max(cwnd, tcp_packets_in_flight(tp) + acked);
 		return true;	/* yes, using packet conservation */
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct bbr *bbr = inet_csk_ca(sk);
-	u32 cwnd = 0, target_cwnd = 0;
+	u32 cwnd = tp->snd_cwnd, target_cwnd = 0;
 	if (!acked)
-		return;
+		goto done;  /* no packet fully ACKed; just apply caps */
 	if (bbr_set_cwnd_to_recover_or_restore(sk, rs, acked, &cwnd))
 		goto done;
 		bbr_reset_probe_bw_mode(sk);  /* we estimate queue is drained */
 }
+static void bbr_check_probe_rtt_done(struct sock *sk)
+{
+	struct tcp_sock *tp = tcp_sk(sk);
+	struct bbr *bbr = inet_csk_ca(sk);
+	if (!(bbr->probe_rtt_done_stamp &&
+	      after(tcp_jiffies32, bbr->probe_rtt_done_stamp)))
+		return;
+	bbr->min_rtt_stamp = tcp_jiffies32;  /* wait a while until PROBE_RTT */
+	tp->snd_cwnd = max(tp->snd_cwnd, bbr->prior_cwnd);
+	bbr_reset_mode(sk);
+}
 /* The goal of PROBE_RTT mode is to have BBR flows cooperatively and
  * periodically drain the bottleneck queue, to converge to measure the true
  * min_rtt (unloaded propagation delay). This allows the flows to keep queues
 		} else if (bbr->probe_rtt_done_stamp) {
 			if (bbr->round_start)
 				bbr->probe_rtt_round_done = 1;
-			if (bbr->probe_rtt_round_done &&
+			if (bbr->probe_rtt_round_done)
-			    after(tcp_jiffies32, bbr->probe_rtt_done_stamp)) {
+				bbr_check_probe_rtt_done(sk);
-				bbr->min_rtt_stamp = tcp_jiffies32;
-				bbr->restore_cwnd = 1;  /* snap to prior_cwnd */
-				bbr_reset_mode(sk);
-			}
 		}
 	}
 	/* Restart after idle ends only once we process a new S/ACK for data */
 	bbr->has_seen_rtt = 0;
 	bbr_init_pacing_rate_from_rtt(sk);
-	bbr->restore_cwnd = 0;
 	bbr->round_start = 0;
 	bbr->idle_restart = 0;
 	bbr->full_bw_reached = 0;

net/ipv4/tcp_ipv4.c+6−0

 		if (res)
 			goto fail;
 		sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
+		/* Please enforce IP_DF and IPID==0 for RST and
+		 * ACK sent in SYN-RECV and TIME-WAIT state.
+		 */
+		inet_sk(sk)->pmtudisc = IP_PMTUDISC_DO;
 		*per_cpu_ptr(net->ipv4.tcp_sk, cpu) = sk;
 	}

net/ipv6/addrconf.c+3−3

@@ -2398,7 +2398,7 @@ static void addrconf_add_mroute(struct net_device *dev) · 2397 unmodified lines
2398		2398
2399	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);	2399	ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
2400		2400
2401	ip6_route_add(&cfg, GFP_ATOMIC, NULL);	2401	ip6_route_add(&cfg, GFP_KERNEL, NULL);
2402	}	2402	}
2403		2403
2404	static struct inet6_dev addrconf_add_dev(struct net_device dev)	2404	static struct inet6_dev addrconf_add_dev(struct net_device dev)
@@ -3062,7 +3062,7 @@ static void sit_add_v4_addrs(struct inet6_dev *idev) · 657 unmodified lines
3062	if (addr.s6_addr32[3]) {	3062	if (addr.s6_addr32[3]) {
3063	add_addr(idev, &addr, plen, scope);	3063	add_addr(idev, &addr, plen, scope);
3064	addrconf_prefix_route(&addr, plen, 0, idev->dev, 0, pflags,	3064	addrconf_prefix_route(&addr, plen, 0, idev->dev, 0, pflags,
3065	GFP_ATOMIC);	3065	GFP_KERNEL);
3066	return;	3066	return;
3067	}	3067	}
3068		3068
@@ -3087,7 +3087,7 @@ static void sit_add_v4_addrs(struct inet6_dev *idev) · 18 unmodified lines
3087		3087
3088	add_addr(idev, &addr, plen, flag);	3088	add_addr(idev, &addr, plen, flag);
3089	addrconf_prefix_route(&addr, plen, 0, idev->dev,	3089	addrconf_prefix_route(&addr, plen, 0, idev->dev,
3090	0, pflags, GFP_ATOMIC);	3090	0, pflags, GFP_KERNEL);
3091	}	3091	}
3092	}	3092	}
3093	}	3093	}

net/ipv6/ip6_fib.c+2−0

@@ -198,6 +198,8 @@ void fib6_info_destroy_rcu(struct rcu_head *head) · 197 unmodified lines
198	}	198	}
199	}	199	}
200		200
		201	lwtstate_put(f6i->fib6_nh.nh_lwtstate);
		202
201	if (f6i->fib6_nh.nh_dev)	203	if (f6i->fib6_nh.nh_dev)
202	dev_put(f6i->fib6_nh.nh_dev);	204	dev_put(f6i->fib6_nh.nh_dev);
203		205

net/ipv6/ip6_vti.c+2−1

@@ -1094,7 +1094,8 @@ static void __net_exit vti6_destroy_tunnels(struct vti6_net *ip6n, · 1093 unmodified lines
1094	}	1094	}
1095		1095
1096	t = rtnl_dereference(ip6n->tnls_wc[0]);	1096	t = rtnl_dereference(ip6n->tnls_wc[0]);
1097	unregister_netdevice_queue(t->dev, list);	1097	if (t)
		1098	unregister_netdevice_queue(t->dev, list);
1098	}	1099	}
1099		1100
1100	static int __net_init vti6_init_net(struct net *net)	1101	static int __net_init vti6_init_net(struct net *net)

net/ipv6/route.c+1−1

@@ -956,7 +956,7 @@ static void ip6_rt_init_dst(struct rt6_info rt, struct fib6_info ort) · 955 unmodified lines
956	rt->dst.error = 0;	956	rt->dst.error = 0;
957	rt->dst.output = ip6_output;	957	rt->dst.output = ip6_output;
958		958
959	if (ort->fib6_type == RTN_LOCAL) {	959	if (ort->fib6_type == RTN_LOCAL \|\| ort->fib6_type == RTN_ANYCAST) {
960	rt->dst.input = ip6_input;	960	rt->dst.input = ip6_input;
961	} else if (ipv6_addr_type(&ort->fib6_dst.addr) & IPV6_ADDR_MULTICAST) {	961	} else if (ipv6_addr_type(&ort->fib6_dst.addr) & IPV6_ADDR_MULTICAST) {
962	rt->dst.input = ip6_mc_input;	962	rt->dst.input = ip6_mc_input;

net/ncsi/ncsi-netlink.c+2−2

@@ -100,7 +100,7 @@ static int ncsi_write_package_info(struct sk_buff *skb, · 99 unmodified lines
100	bool found;	100	bool found;
101	int rc;	101	int rc;
102		102
103	if (id > ndp->package_num) {	103	if (id > ndp->package_num - 1) {
104	netdev_info(ndp->ndev.dev, "NCSI: No package with id %u\n", id);	104	netdev_info(ndp->ndev.dev, "NCSI: No package with id %u\n", id);
105	return -ENODEV;	105	return -ENODEV;
106	}	106	}
@@ -240,7 +240,7 @@ static int ncsi_pkg_info_all_nl(struct sk_buff *skb, · 133 unmodified lines
240	return 0; /* done */	240	return 0; /* done */
241		241
242	hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,	242	hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
243	&ncsi_genl_family, 0, NCSI_CMD_PKG_INFO);	243	&ncsi_genl_family, NLM_F_MULTI, NCSI_CMD_PKG_INFO);
244	if (!hdr) {	244	if (!hdr) {
245	rc = -EMSGSIZE;	245	rc = -EMSGSIZE;
246	goto err;	246	goto err;

net/rds/tcp.c+0−1

@@ -37,7 +37,6 @@ · 36 unmodified lines
37	#include <net/tcp.h>	37	#include <net/tcp.h>
38	#include <net/net_namespace.h>	38	#include <net/net_namespace.h>
39	#include <net/netns/generic.h>	39	#include <net/netns/generic.h>
40	#include <net/tcp.h>
41	#include <net/addrconf.h>	40	#include <net/addrconf.h>
42		41
43	#include "rds.h"	42	#include "rds.h"

net/sched/act_api.c+25−45

 }
 EXPORT_SYMBOL(tcf_generic_walker);
-static bool __tcf_idr_check(struct tc_action_net *tn, u32 index,
+int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index)
-			    struct tc_action **a, int bind)
 {
 	struct tcf_idrinfo *idrinfo = tn->idrinfo;
 	struct tc_action *p;
 	spin_lock(&idrinfo->lock);
 	p = idr_find(&idrinfo->action_idr, index);
-	if (IS_ERR(p)) {
+	if (IS_ERR(p))
 		p = NULL;
-	} else if (p) {
+	else if (p)
 		refcount_inc(&p->tcfa_refcnt);
-		if (bind)
-			atomic_inc(&p->tcfa_bindcnt);
-	}
 	spin_unlock(&idrinfo->lock);
 	if (p) {
 	}
 	return false;
 }
-int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index)
-{
-	return __tcf_idr_check(tn, index, a, 0);
-}
 EXPORT_SYMBOL(tcf_idr_search);
-bool tcf_idr_check(struct tc_action_net *tn, u32 index, struct tc_action **a,
+static int tcf_idr_delete_index(struct tcf_idrinfo *idrinfo, u32 index)
-		   int bind)
 {
-	return __tcf_idr_check(tn, index, a, bind);
-}
-EXPORT_SYMBOL(tcf_idr_check);
-int tcf_idr_delete_index(struct tc_action_net *tn, u32 index)
-{
-	struct tcf_idrinfo *idrinfo = tn->idrinfo;
 	struct tc_action *p;
 	int ret = 0;
 	spin_unlock(&idrinfo->lock);
 	return ret;
 }
-EXPORT_SYMBOL(tcf_idr_delete_index);
 int tcf_idr_create(struct tc_action_net *tn, u32 index, struct nlattr *est,
 		   struct tc_action **a, const struct tc_action_ops *ops,
 	p->idrinfo = idrinfo;
 	p->ops = ops;
-	INIT_LIST_HEAD(&p->list);
 	*a = p;
 	return 0;
 err3:
 	return __tcf_action_put(p, false);
 }
+/* Put all actions in this array, skip those NULL's. */
 static void tcf_action_put_many(struct tc_action *actions[])
 {
 	int i;
-	for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) {
+	for (i = 0; i < TCA_ACT_MAX_PRIO; i++) {
 		struct tc_action *a = actions[i];
-		const struct tc_action_ops *ops = a->ops;
+		const struct tc_action_ops *ops;
+		if (!a)
+			continue;
+		ops = a->ops;
 		if (tcf_action_put(a))
 			module_put(ops->owner);
 	}
 	return err;
 }
-static int tcf_action_delete(struct net *net, struct tc_action *actions[],
+static int tcf_action_delete(struct net *net, struct tc_action *actions[])
-			     int *acts_deleted, struct netlink_ext_ack *extack)
 {
-	u32 act_index;
+	int i;
-	int ret, i;
 	for (i = 0; i < TCA_ACT_MAX_PRIO && actions[i]; i++) {
 		struct tc_action *a = actions[i];
 		const struct tc_action_ops *ops = a->ops;
 		/* Actions can be deleted concurrently so we must save their
 		 * type and id to search again after reference is released.
 		 */
-		act_index = a->tcfa_index;
+		struct tcf_idrinfo *idrinfo = a->idrinfo;
+		u32 act_index = a->tcfa_index;
 		if (tcf_action_put(a)) {
 			/* last reference, action was deleted concurrently */
 			module_put(ops->owner);
 		} else  {
+			int ret;
 			/* now do the delete */
-			ret = ops->delete(net, act_index);
+			ret = tcf_idr_delete_index(idrinfo, act_index);
-			if (ret < 0) {
+			if (ret < 0)
-				*acts_deleted = i + 1;
 				return ret;
-			}
 		}
+		actions[i] = NULL;
 	}
-	*acts_deleted = i;
 	return 0;
 }
 static int
 tcf_del_notify(struct net *net, struct nlmsghdr *n, struct tc_action *actions[],
-	       int *acts_deleted, u32 portid, size_t attr_size,
+	       u32 portid, size_t attr_size, struct netlink_ext_ack *extack)
-	       struct netlink_ext_ack *extack)
 {
 	int ret;
 	struct sk_buff *skb;
 	}
 	/* now do the delete */
-	ret = tcf_action_delete(net, actions, acts_deleted, extack);
+	ret = tcf_action_delete(net, actions);
 	if (ret < 0) {
 		NL_SET_ERR_MSG(extack, "Failed to delete TC action");
 		kfree_skb(skb);
 	struct nlattr *tb[TCA_ACT_MAX_PRIO + 1];
 	struct tc_action *act;
 	size_t attr_size = 0;
-	struct tc_action *actions[TCA_ACT_MAX_PRIO + 1] = {};
+	struct tc_action *actions[TCA_ACT_MAX_PRIO] = {};
-	int acts_deleted = 0;
 	ret = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL, extack);
 	if (ret < 0)
 	if (event == RTM_GETACTION)
 		ret = tcf_get_notify(net, portid, n, actions, event, extack);
 	else { /* delete */
-		ret = tcf_del_notify(net, n, actions, &acts_deleted, portid,
+		ret = tcf_del_notify(net, n, actions, portid, attr_size, extack);
-				     attr_size, extack);
 		if (ret)
 			goto err;
-		return ret;
+		return 0;
 	}
 err:
-	tcf_action_put_many(&actions[acts_deleted]);
+	tcf_action_put_many(actions);
 	return ret;
 }

net/sched/act_bpf.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_bpf_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, bpf_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_bpf_ops __read_mostly = {
 	.kind		=	"bpf",
 	.type		=	TCA_ACT_BPF,
 	.init		=	tcf_bpf_init,
 	.walk		=	tcf_bpf_walker,
 	.lookup		=	tcf_bpf_search,
-	.delete		=	tcf_bpf_delete,
 	.size		=	sizeof(struct tcf_bpf),
 };

net/sched/act_connmark.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_connmark_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, connmark_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_connmark_ops = {
 	.kind		=	"connmark",
 	.type		=	TCA_ACT_CONNMARK,
 	.init		=	tcf_connmark_init,
 	.walk		=	tcf_connmark_walker,
 	.lookup		=	tcf_connmark_search,
-	.delete		=	tcf_connmark_delete,
 	.size		=	sizeof(struct tcf_connmark_info),
 };

net/sched/act_csum.c+0−8

 	return nla_total_size(sizeof(struct tc_csum));
 }
-static int tcf_csum_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, csum_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_csum_ops = {
 	.kind		= "csum",
 	.type		= TCA_ACT_CSUM,
 	.walk		= tcf_csum_walker,
 	.lookup		= tcf_csum_search,
 	.get_fill_size  = tcf_csum_get_fill_size,
-	.delete		= tcf_csum_delete,
 	.size		= sizeof(struct tcf_csum),
 };

net/sched/act_gact.c+0−8

 	return sz;
 }
-static int tcf_gact_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, gact_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_gact_ops = {
 	.kind		=	"gact",
 	.type		=	TCA_ACT_GACT,
 	.walk		=	tcf_gact_walker,
 	.lookup		=	tcf_gact_search,
 	.get_fill_size	=	tcf_gact_get_fill_size,
-	.delete		=	tcf_gact_delete,
 	.size		=	sizeof(struct tcf_gact),
 };

net/sched/act_ife.c+40−52

 {
 	struct tcf_meta_ops *o;
-	read_lock_bh(&ife_mod_lock);
+	read_lock(&ife_mod_lock);
 	list_for_each_entry(o, &ifeoplist, list) {
 		if (o->metaid == metaid) {
 			if (!try_module_get(o->owner))
 				o = NULL;
-			read_unlock_bh(&ife_mod_lock);
+			read_unlock(&ife_mod_lock);
 			return o;
 		}
 	}
-	read_unlock_bh(&ife_mod_lock);
+	read_unlock(&ife_mod_lock);
 	return NULL;
 }
 	    !mops->get || !mops->alloc)
 		return -EINVAL;
-	write_lock_bh(&ife_mod_lock);
+	write_lock(&ife_mod_lock);
 	list_for_each_entry(m, &ifeoplist, list) {
 		if (m->metaid == mops->metaid ||
 		    (strcmp(mops->name, m->name) == 0)) {
-			write_unlock_bh(&ife_mod_lock);
+			write_unlock(&ife_mod_lock);
 			return -EEXIST;
 		}
 	}
 		mops->release = ife_release_meta_gen;
 	list_add_tail(&mops->list, &ifeoplist);
-	write_unlock_bh(&ife_mod_lock);
+	write_unlock(&ife_mod_lock);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(unregister_ife_op);
 	struct tcf_meta_ops *m;
 	int err = -ENOENT;
-	write_lock_bh(&ife_mod_lock);
+	write_lock(&ife_mod_lock);
 	list_for_each_entry(m, &ifeoplist, list) {
 		if (m->metaid == mops->metaid) {
 			list_del(&mops->list);
 			break;
 		}
 	}
-	write_unlock_bh(&ife_mod_lock);
+	write_unlock(&ife_mod_lock);
 	return err;
 }
 #endif
 /* called when adding new meta information
- * under ife->tcf_lock for existing action
 */
-static int load_metaops_and_vet(struct tcf_ife_info *ife, u32 metaid,
+static int load_metaops_and_vet(u32 metaid, void *val, int len, bool rtnl_held)
-				void *val, int len, bool exists,
-				bool rtnl_held)
 {
 	struct tcf_meta_ops *ops = find_ife_oplist(metaid);
 	int ret = 0;
 	if (!ops) {
 		ret = -ENOENT;
 #ifdef CONFIG_MODULES
-		if (exists)
-			spin_unlock_bh(&ife->tcf_lock);
 		if (rtnl_held)
 			rtnl_unlock();
 		request_module("ife-meta-%s", ife_meta_id2name(metaid));
 		if (rtnl_held)
 			rtnl_lock();
-		if (exists)
-			spin_lock_bh(&ife->tcf_lock);
 		ops = find_ife_oplist(metaid);
 #endif
 	}
 }
 /* called when adding new meta information
- * under ife->tcf_lock for existing action
 */
-static int add_metainfo(struct tcf_ife_info *ife, u32 metaid, void *metaval,
+static int __add_metainfo(const struct tcf_meta_ops *ops,
-			int len, bool atomic)
+			  struct tcf_ife_info *ife, u32 metaid, void *metaval,
+			  int len, bool atomic, bool exists)
 {
 	struct tcf_meta_info *mi = NULL;
-	struct tcf_meta_ops *ops = find_ife_oplist(metaid);
 	int ret = 0;
-	if (!ops)
-		return -ENOENT;
 	mi = kzalloc(sizeof(*mi), atomic ? GFP_ATOMIC : GFP_KERNEL);
-	if (!mi) {
+	if (!mi)
-		/*put back what find_ife_oplist took */
-		module_put(ops->owner);
 		return -ENOMEM;
-	}
 	mi->metaid = metaid;
 	mi->ops = ops;
 		ret = ops->alloc(mi, metaval, atomic ? GFP_ATOMIC : GFP_KERNEL);
 		if (ret != 0) {
 			kfree(mi);
-			module_put(ops->owner);
 			return ret;
 		}
 	}
+	if (exists)
+		spin_lock_bh(&ife->tcf_lock);
 	list_add_tail(&mi->metalist, &ife->metalist);
+	if (exists)
+		spin_unlock_bh(&ife->tcf_lock);
+	return ret;
+}
+static int add_metainfo(struct tcf_ife_info *ife, u32 metaid, void *metaval,
+			int len, bool exists)
+{
+	const struct tcf_meta_ops *ops = find_ife_oplist(metaid);
+	int ret;
+	if (!ops)
+		return -ENOENT;
+	ret = __add_metainfo(ops, ife, metaid, metaval, len, false, exists);
+	if (ret)
+		/*put back what find_ife_oplist took */
+		module_put(ops->owner);
 	return ret;
 }
-static int use_all_metadata(struct tcf_ife_info *ife)
+static int use_all_metadata(struct tcf_ife_info *ife, bool exists)
 {
 	struct tcf_meta_ops *o;
 	int rc = 0;
 	int installed = 0;
-	read_lock_bh(&ife_mod_lock);
+	read_lock(&ife_mod_lock);
 	list_for_each_entry(o, &ifeoplist, list) {
-		rc = add_metainfo(ife, o->metaid, NULL, 0, true);
+		rc = __add_metainfo(o, ife, o->metaid, NULL, 0, true, exists);
 		if (rc == 0)
 			installed += 1;
 	}
-	read_unlock_bh(&ife_mod_lock);
+	read_unlock(&ife_mod_lock);
 	if (installed)
 		return 0;
 		kfree_rcu(p, rcu);
 }
-/* under ife->tcf_lock for existing action */
 static int populate_metalist(struct tcf_ife_info *ife, struct nlattr **tb,
 			     bool exists, bool rtnl_held)
 {
 			val = nla_data(tb[i]);
 			len = nla_len(tb[i]);
-			rc = load_metaops_and_vet(ife, i, val, len, exists,
+			rc = load_metaops_and_vet(i, val, len, rtnl_held);
-						  rtnl_held);
 			if (rc != 0)
 				return rc;
 		p->eth_type = ife_type;
 	}
-	if (exists)
-		spin_lock_bh(&ife->tcf_lock);
 	if (ret == ACT_P_CREATED)
 		INIT_LIST_HEAD(&ife->metalist);
 				       NULL, NULL);
 		if (err) {
 metadata_parse_err:
-			if (exists)
-				spin_unlock_bh(&ife->tcf_lock);
 			tcf_idr_release(*a, bind);
 			kfree(p);
 			return err;
 		}
 		 * as we can. You better have at least one else we are
 		 * going to bail out
 		 */
-		err = use_all_metadata(ife);
+		err = use_all_metadata(ife, exists);
 		if (err) {
-			if (exists)
-				spin_unlock_bh(&ife->tcf_lock);
 			tcf_idr_release(*a, bind);
 			kfree(p);
 			return err;
 		}
 	}
+	if (exists)
+		spin_lock_bh(&ife->tcf_lock);
 	ife->tcf_action = parm->action;
 	/* protected by tcf_lock when modifying existing action */
 	rcu_swap_protected(ife->params, p, 1);
 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_ife_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, ife_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_ife_ops = {
 	.kind = "ife",
 	.type = TCA_ACT_IFE,
 	.init = tcf_ife_init,
 	.walk = tcf_ife_walker,
 	.lookup = tcf_ife_search,
-	.delete = tcf_ife_delete,
 	.size =	sizeof(struct tcf_ife_info),
 };

net/sched/act_ipt.c+0−16

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_ipt_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, ipt_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_ipt_ops = {
 	.kind		=	"ipt",
 	.type		=	TCA_ACT_IPT,
 	.init		=	tcf_ipt_init,
 	.walk		=	tcf_ipt_walker,
 	.lookup		=	tcf_ipt_search,
-	.delete		=	tcf_ipt_delete,
 	.size		=	sizeof(struct tcf_ipt),
 };
 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_xt_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, xt_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_xt_ops = {
 	.kind		=	"xt",
 	.type		=	TCA_ACT_XT,
 	.init		=	tcf_xt_init,
 	.walk		=	tcf_xt_walker,
 	.lookup		=	tcf_xt_search,
-	.delete		=	tcf_xt_delete,
 	.size		=	sizeof(struct tcf_ipt),
 };

net/sched/act_mirred.c+0−8

 	dev_put(dev);
 }
-static int tcf_mirred_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, mirred_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_mirred_ops = {
 	.kind		=	"mirred",
 	.type		=	TCA_ACT_MIRRED,
 	.size		=	sizeof(struct tcf_mirred),
 	.get_dev	=	tcf_mirred_get_dev,
 	.put_dev	=	tcf_mirred_put_dev,
-	.delete		=	tcf_mirred_delete,
 };
 static __net_init int mirred_init_net(struct net *net)

net/sched/act_nat.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_nat_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, nat_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_nat_ops = {
 	.kind		=	"nat",
 	.type		=	TCA_ACT_NAT,
 	.init		=	tcf_nat_init,
 	.walk		=	tcf_nat_walker,
 	.lookup		=	tcf_nat_search,
-	.delete		=	tcf_nat_delete,
 	.size		=	sizeof(struct tcf_nat),
 };

net/sched/act_pedit.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_pedit_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, pedit_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_pedit_ops = {
 	.kind		=	"pedit",
 	.type		=	TCA_ACT_PEDIT,
 	.init		=	tcf_pedit_init,
 	.walk		=	tcf_pedit_walker,
 	.lookup		=	tcf_pedit_search,
-	.delete		=	tcf_pedit_delete,
 	.size		=	sizeof(struct tcf_pedit),
 };

net/sched/act_police.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_police_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, police_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 MODULE_AUTHOR("Alexey Kuznetsov");
 MODULE_DESCRIPTION("Policing actions");
 MODULE_LICENSE("GPL");
 	.init		=	tcf_police_init,
 	.walk		=	tcf_police_walker,
 	.lookup		=	tcf_police_search,
-	.delete		=	tcf_police_delete,
 	.size		=	sizeof(struct tcf_police),
 };

net/sched/act_sample.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_sample_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, sample_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_sample_ops = {
 	.kind	  = "sample",
 	.type	  = TCA_ACT_SAMPLE,
 	.cleanup  = tcf_sample_cleanup,
 	.walk	  = tcf_sample_walker,
 	.lookup	  = tcf_sample_search,
-	.delete	  = tcf_sample_delete,
 	.size	  = sizeof(struct tcf_sample),
 };

net/sched/act_simple.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_simp_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, simp_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_simp_ops = {
 	.kind		=	"simple",
 	.type		=	TCA_ACT_SIMP,
 	.init		=	tcf_simp_init,
 	.walk		=	tcf_simp_walker,
 	.lookup		=	tcf_simp_search,
-	.delete		=	tcf_simp_delete,
 	.size		=	sizeof(struct tcf_defact),
 };

net/sched/act_skbedit.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_skbedit_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, skbedit_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_skbedit_ops = {
 	.kind		=	"skbedit",
 	.type		=	TCA_ACT_SKBEDIT,
 	.cleanup	=	tcf_skbedit_cleanup,
 	.walk		=	tcf_skbedit_walker,
 	.lookup		=	tcf_skbedit_search,
-	.delete		=	tcf_skbedit_delete,
 	.size		=	sizeof(struct tcf_skbedit),
 };

net/sched/act_skbmod.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_skbmod_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, skbmod_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_skbmod_ops = {
 	.kind		=	"skbmod",
 	.type		=	TCA_ACT_SKBMOD,
 	.cleanup	=	tcf_skbmod_cleanup,
 	.walk		=	tcf_skbmod_walker,
 	.lookup		=	tcf_skbmod_search,
-	.delete		=	tcf_skbmod_delete,
 	.size		=	sizeof(struct tcf_skbmod),
 };

net/sched/act_tunnel_key.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tunnel_key_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_tunnel_key_ops = {
 	.kind		=	"tunnel_key",
 	.type		=	TCA_ACT_TUNNEL_KEY,
 	.cleanup	=	tunnel_key_release,
 	.walk		=	tunnel_key_walker,
 	.lookup		=	tunnel_key_search,
-	.delete		=	tunnel_key_delete,
 	.size		=	sizeof(struct tcf_tunnel_key),
 };

net/sched/act_vlan.c+0−8

 	return tcf_idr_search(tn, a, index);
 }
-static int tcf_vlan_delete(struct net *net, u32 index)
-{
-	struct tc_action_net *tn = net_generic(net, vlan_net_id);
-	return tcf_idr_delete_index(tn, index);
-}
 static struct tc_action_ops act_vlan_ops = {
 	.kind		=	"vlan",
 	.type		=	TCA_ACT_VLAN,
 	.cleanup	=	tcf_vlan_cleanup,
 	.walk		=	tcf_vlan_walker,
 	.lookup		=	tcf_vlan_search,
-	.delete		=	tcf_vlan_delete,
 	.size		=	sizeof(struct tcf_vlan),
 };

net/sched/cls_u32.c+8−2

 	struct nlattr *opt = tca[TCA_OPTIONS];
 	struct nlattr *tb[TCA_U32_MAX + 1];
 	u32 htid, flags = 0;
+	size_t sel_size;
 	int err;
 #ifdef CONFIG_CLS_U32_PERF
 	size_t size;
 	}
 	s = nla_data(tb[TCA_U32_SEL]);
+	sel_size = struct_size(s, keys, s->nkeys);
+	if (nla_len(tb[TCA_U32_SEL]) < sel_size) {
+		err = -EINVAL;
+		goto erridr;
+	}
-	n = kzalloc(sizeof(*n) + s->nkeys*sizeof(struct tc_u32_key), GFP_KERNEL);
+	n = kzalloc(offsetof(typeof(*n), sel) + sel_size, GFP_KERNEL);
 	if (n == NULL) {
 		err = -ENOBUFS;
 		goto erridr;
 	}
 #endif
-	memcpy(&n->sel, s, sizeof(*s) + s->nkeys*sizeof(struct tc_u32_key));
+	memcpy(&n->sel, s, sel_size);
 	RCU_INIT_POINTER(n->ht_up, ht);
 	n->handle = handle;
 	n->fshift = s->hmask ? ffs(ntohl(s->hmask)) - 1 : 0;

net/sched/sch_cake.c+19−5

 #include <linux/vmalloc.h>
 #include <linux/reciprocal_div.h>
 #include <net/netlink.h>
-#include <linux/version.h>
 #include <linux/if_vlan.h>
 #include <net/pkt_sched.h>
 #include <net/pkt_cls.h>
 }
 static u32 cake_hash(struct cake_tin_data *q, const struct sk_buff *skb,
-		     int flow_mode)
+		     int flow_mode, u16 flow_override, u16 host_override)
 {
-	u32 flow_hash = 0, srchost_hash, dsthost_hash;
+	u32 flow_hash = 0, srchost_hash = 0, dsthost_hash = 0;
 	u16 reduced_hash, srchost_idx, dsthost_idx;
 	struct flow_keys keys, host_keys;
 	if (unlikely(flow_mode == CAKE_FLOW_NONE))
 		return 0;
+	/* If both overrides are set we can skip packet dissection entirely */
+	if ((flow_override || !(flow_mode & CAKE_FLOW_FLOWS)) &&
+	    (host_override || !(flow_mode & CAKE_FLOW_HOSTS)))
+		goto skip_hash;
 	skb_flow_dissect_flow_keys(skb, &keys,
 				   FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL);
 	if (flow_mode & CAKE_FLOW_FLOWS)
 		flow_hash = flow_hash_from_keys(&keys);
+skip_hash:
+	if (flow_override)
+		flow_hash = flow_override - 1;
+	if (host_override) {
+		dsthost_hash = host_override - 1;
+		srchost_hash = host_override - 1;
+	}
 	if (!(flow_mode & CAKE_FLOW_FLOWS)) {
 		if (flow_mode & CAKE_FLOW_SRC_IP)
 			flow_hash ^= srchost_hash;
 	struct cake_sched_data *q = qdisc_priv(sch);
 	struct tcf_proto *filter;
 	struct tcf_result res;
-	u32 flow = 0;
+	u16 flow = 0, host = 0;
 	int result;
 	filter = rcu_dereference_bh(q->filter_list);
 #endif
 		if (TC_H_MIN(res.classid) <= CAKE_QUEUES)
 			flow = TC_H_MIN(res.classid);
+		if (TC_H_MAJ(res.classid) <= (CAKE_QUEUES << 16))
+			host = TC_H_MAJ(res.classid) >> 16;
 	}
 hash:
 	*t = cake_select_tin(sch, skb);
-	return flow ?: cake_hash(*t, skb, flow_mode) + 1;
+	return cake_hash(*t, skb, flow_mode, flow, host) + 1;
 }
 static void cake_reconfigure(struct Qdisc *sch);

net/tls/tls_main.c+7−2

 {
 	struct tls_context *ctx = tls_get_ctx(sk);
-	/* We are already sending pages, ignore notification */
+	/* If in_tcp_sendpages call lower protocol write space handler
-	if (ctx->in_tcp_sendpages)
+	 * to ensure we wake up any waiting operations there. For example
+	 * if do_tcp_sendpages where to call sk_wait_event.
+	 */
+	if (ctx->in_tcp_sendpages) {
+		ctx->sk_write_space(sk);
 		return;
+	}
 	if (!sk->sk_write_pending && tls_is_pending_closed_record(ctx)) {
 		gfp_t sk_allocation = sk->sk_allocation;

net/xdp/xdp_umem.c+2−2

@@ -74,14 +74,14 @@ int xdp_umem_assign_dev(struct xdp_umem umem, struct net_device dev, · 73 unmodified lines
74	return 0;	74	return 0;
75		75
76	if (!dev->netdev_ops->ndo_bpf \|\| !dev->netdev_ops->ndo_xsk_async_xmit)	76	if (!dev->netdev_ops->ndo_bpf \|\| !dev->netdev_ops->ndo_xsk_async_xmit)
77	return force_zc ? -ENOTSUPP : 0; /* fail or fallback */	77	return force_zc ? -EOPNOTSUPP : 0; /* fail or fallback */
78		78
79	bpf.command = XDP_QUERY_XSK_UMEM;	79	bpf.command = XDP_QUERY_XSK_UMEM;
80		80
81	rtnl_lock();	81	rtnl_lock();
82	err = xdp_umem_query(dev, queue_id);	82	err = xdp_umem_query(dev, queue_id);
83	if (err) {	83	if (err) {
84	err = err < 0 ? -ENOTSUPP : -EBUSY;	84	err = err < 0 ? -EOPNOTSUPP : -EBUSY;
85	goto err_rtnl_unlock;	85	goto err_rtnl_unlock;
86	}	86	}
87		87

tools/bpf/bpftool/map_perf_ring.c+4−1

 	}
 	while (argc) {
-		if (argc < 2)
+		if (argc < 2) {
 			BAD_ARG();
+			goto err_close_map;
+		}
 		if (is_prefix(*argv, "cpu")) {
 			char *endptr;
 			NEXT_ARG();
 		} else {
 			BAD_ARG();
+			goto err_close_map;
 		}
 		do_all = false;

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code