tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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

Pull networking fixes from David Miller:

1) Fix ieeeu02154 atusb driver use-after-free, from Johan Hovold.

2) Need to validate TCA_CBQ_WRROPT netlink attributes, from Eric
Dumazet.

3) txq null deref in mac80211, from Miaoqing Pan.

4) ionic driver needs to select NET_DEVLINK, from Arnd Bergmann.

5) Need to disable bh during nft_connlimit GC, from Pablo Neira Ayuso.

6) Avoid division by zero in taprio scheduler, from Vladimir Oltean.

7) Various xgmac fixes in stmmac driver from Jose Abreu.

8) Avoid 64-bit division in mlx5 leading to link errors on 32-bit from
Michal Kubecek.

9) Fix bad VLAN check in rtl8366 DSA driver, from Linus Walleij.

10) Fix sleep while atomic in sja1105, from Vladimir Oltean.

11) Suspend/resume deadlock in stmmac, from Thierry Reding.

12) Various UDP GSO fixes from Josh Hunt.

13) Fix slab out of bounds access in tcp_zerocopy_receive(), from Eric
Dumazet.

14) Fix OOPS in __ipv6_ifa_notify(), from David Ahern.

15) Memory leak in NFC's llcp_sock_bind, from Eric Dumazet.

* git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (72 commits)
selftests/net: add nettest to .gitignore
net: qlogic: Fix memory leak in ql_alloc_large_buffers
nfc: fix memory leak in llcp_sock_bind()
sch_dsmark: fix potential NULL deref in dsmark_init()
net: phy: at803x: use operating parameters from PHY-specific status
net: phy: extract pause mode
net: phy: extract link partner advertisement reading
net: phy: fix write to mii-ctrl1000 register
ipv6: Handle missing host route in __ipv6_ifa_notify
net: phy: allow for reset line to be tied to a sleepy GPIO controller
net: ipv4: avoid mixed n_redirects and rate_tokens usage
r8152: Set macpassthru in reset_resume callback
cxgb4:Fix out-of-bounds MSI-X info array access
Revert "ipv6: Handle race in addrconf_dad_work"
net: make sock_prot_memory_pressure() return "const char *"
rxrpc: Fix rxrpc_recvmsg tracepoint
qmi_wwan: add support for Cinterion CLS8 devices
tcp: fix slab-out-of-bounds in tcp_zerocopy_receive()
lib: textsearch: fix escapes in example code
udp: only do GSO if # of segs > 1
...

Linus Torvalds 9819a30c 6fe137cb

+539 -281
+1
Documentation/networking/device_drivers/index.rst
··· 23 23 intel/ice 24 24 google/gve 25 25 mellanox/mlx5 26 + netronome/nfp 26 27 pensando/ionic 27 28 28 29 .. only:: subproject and html
+1 -1
Documentation/networking/j1939.rst
··· 272 272 * MSG_DONTWAIT, i.e. non-blocking operation. 273 273 274 274 recvmsg(2) 275 - ^^^^^^^^^ 275 + ^^^^^^^^^^ 276 276 277 277 In most cases recvmsg(2) is needed if you want to extract more information than 278 278 recvfrom(2) can provide. For example package priority and timestamp. The
+2 -2
drivers/net/dsa/qca8k.c
··· 705 705 BIT(0) << QCA8K_GLOBAL_FW_CTRL1_UC_DP_S); 706 706 707 707 /* Setup connection between CPU port & user ports */ 708 - for (i = 0; i < DSA_MAX_PORTS; i++) { 708 + for (i = 0; i < QCA8K_NUM_PORTS; i++) { 709 709 /* CPU port gets connected to all user ports of the switch */ 710 710 if (dsa_is_cpu_port(ds, i)) { 711 711 qca8k_rmw(priv, QCA8K_PORT_LOOKUP_CTRL(QCA8K_CPU_PORT), ··· 1077 1077 if (id != QCA8K_ID_QCA8337) 1078 1078 return -ENODEV; 1079 1079 1080 - priv->ds = dsa_switch_alloc(&mdiodev->dev, DSA_MAX_PORTS); 1080 + priv->ds = dsa_switch_alloc(&mdiodev->dev, QCA8K_NUM_PORTS); 1081 1081 if (!priv->ds) 1082 1082 return -ENOMEM; 1083 1083
+7 -4
drivers/net/dsa/rtl8366.c
··· 339 339 const struct switchdev_obj_port_vlan *vlan) 340 340 { 341 341 struct realtek_smi *smi = ds->priv; 342 + u16 vid; 342 343 int ret; 343 344 344 - if (!smi->ops->is_vlan_valid(smi, port)) 345 - return -EINVAL; 345 + for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++) 346 + if (!smi->ops->is_vlan_valid(smi, vid)) 347 + return -EINVAL; 346 348 347 349 dev_info(smi->dev, "prepare VLANs %04x..%04x\n", 348 350 vlan->vid_begin, vlan->vid_end); ··· 372 370 u16 vid; 373 371 int ret; 374 372 375 - if (!smi->ops->is_vlan_valid(smi, port)) 376 - return; 373 + for (vid = vlan->vid_begin; vid < vlan->vid_end; vid++) 374 + if (!smi->ops->is_vlan_valid(smi, vid)) 375 + return; 377 376 378 377 dev_info(smi->dev, "add VLAN on port %d, %s, %s\n", 379 378 port,
+10 -6
drivers/net/dsa/rtl8366rb.c
··· 507 507 irq = of_irq_get(intc, 0); 508 508 if (irq <= 0) { 509 509 dev_err(smi->dev, "failed to get parent IRQ\n"); 510 - return irq ? irq : -EINVAL; 510 + ret = irq ? irq : -EINVAL; 511 + goto out_put_node; 511 512 } 512 513 513 514 /* This clears the IRQ status register */ ··· 516 515 &val); 517 516 if (ret) { 518 517 dev_err(smi->dev, "can't read interrupt status\n"); 519 - return ret; 518 + goto out_put_node; 520 519 } 521 520 522 521 /* Fetch IRQ edge information from the descriptor */ ··· 538 537 val); 539 538 if (ret) { 540 539 dev_err(smi->dev, "could not configure IRQ polarity\n"); 541 - return ret; 540 + goto out_put_node; 542 541 } 543 542 544 543 ret = devm_request_threaded_irq(smi->dev, irq, NULL, ··· 546 545 "RTL8366RB", smi); 547 546 if (ret) { 548 547 dev_err(smi->dev, "unable to request irq: %d\n", ret); 549 - return ret; 548 + goto out_put_node; 550 549 } 551 550 smi->irqdomain = irq_domain_add_linear(intc, 552 551 RTL8366RB_NUM_INTERRUPT, ··· 554 553 smi); 555 554 if (!smi->irqdomain) { 556 555 dev_err(smi->dev, "failed to create IRQ domain\n"); 557 - return -EINVAL; 556 + ret = -EINVAL; 557 + goto out_put_node; 558 558 } 559 559 for (i = 0; i < smi->num_ports; i++) 560 560 irq_set_parent(irq_create_mapping(smi->irqdomain, i), irq); 561 561 562 - return 0; 562 + out_put_node: 563 + of_node_put(intc); 564 + return ret; 563 565 } 564 566 565 567 static int rtl8366rb_set_addr(struct realtek_smi *smi)
+14 -10
drivers/net/dsa/sja1105/sja1105_main.c
··· 1897 1897 return sja1105_static_config_reload(priv); 1898 1898 } 1899 1899 1900 - /* Caller must hold priv->tagger_data.meta_lock */ 1900 + /* Must be called only with priv->tagger_data.state bit 1901 + * SJA1105_HWTS_RX_EN cleared 1902 + */ 1901 1903 static int sja1105_change_rxtstamping(struct sja1105_private *priv, 1902 1904 bool on) 1903 1905 { ··· 1956 1954 break; 1957 1955 } 1958 1956 1959 - if (rx_on != priv->tagger_data.hwts_rx_en) { 1960 - spin_lock(&priv->tagger_data.meta_lock); 1957 + if (rx_on != test_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state)) { 1958 + clear_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state); 1959 + 1961 1960 rc = sja1105_change_rxtstamping(priv, rx_on); 1962 - spin_unlock(&priv->tagger_data.meta_lock); 1963 1961 if (rc < 0) { 1964 1962 dev_err(ds->dev, 1965 1963 "Failed to change RX timestamping: %d\n", rc); 1966 - return -EFAULT; 1964 + return rc; 1967 1965 } 1968 - priv->tagger_data.hwts_rx_en = rx_on; 1966 + if (rx_on) 1967 + set_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state); 1969 1968 } 1970 1969 1971 1970 if (copy_to_user(ifr->ifr_data, &config, sizeof(config))) ··· 1985 1982 config.tx_type = HWTSTAMP_TX_ON; 1986 1983 else 1987 1984 config.tx_type = HWTSTAMP_TX_OFF; 1988 - if (priv->tagger_data.hwts_rx_en) 1985 + if (test_bit(SJA1105_HWTS_RX_EN, &priv->tagger_data.state)) 1989 1986 config.rx_filter = HWTSTAMP_FILTER_PTP_V2_L2_EVENT; 1990 1987 else 1991 1988 config.rx_filter = HWTSTAMP_FILTER_NONE; ··· 2008 2005 2009 2006 mutex_lock(&priv->ptp_lock); 2010 2007 2011 - now = priv->tstamp_cc.read(&priv->tstamp_cc); 2012 - 2013 2008 while ((skb = skb_dequeue(&data->skb_rxtstamp_queue)) != NULL) { 2014 2009 struct skb_shared_hwtstamps *shwt = skb_hwtstamps(skb); 2015 2010 u64 ts; 2011 + 2012 + now = priv->tstamp_cc.read(&priv->tstamp_cc); 2016 2013 2017 2014 *shwt = (struct skb_shared_hwtstamps) {0}; 2018 2015 ··· 2034 2031 struct sja1105_private *priv = ds->priv; 2035 2032 struct sja1105_tagger_data *data = &priv->tagger_data; 2036 2033 2037 - if (!data->hwts_rx_en) 2034 + if (!test_bit(SJA1105_HWTS_RX_EN, &data->state)) 2038 2035 return false; 2039 2036 2040 2037 /* We need to read the full PTP clock to reconstruct the Rx ··· 2204 2201 tagger_data = &priv->tagger_data; 2205 2202 skb_queue_head_init(&tagger_data->skb_rxtstamp_queue); 2206 2203 INIT_WORK(&tagger_data->rxtstamp_work, sja1105_rxtstamp_work); 2204 + spin_lock_init(&tagger_data->meta_lock); 2207 2205 2208 2206 /* Connections between dsa_port and sja1105_port */ 2209 2207 for (i = 0; i < SJA1105_NUM_PORTS; i++) {
+4 -2
drivers/net/dsa/sja1105/sja1105_spi.c
··· 409 409 rc = static_config_buf_prepare_for_upload(priv, config_buf, buf_len); 410 410 if (rc < 0) { 411 411 dev_err(dev, "Invalid config, cannot upload\n"); 412 - return -EINVAL; 412 + rc = -EINVAL; 413 + goto out; 413 414 } 414 415 /* Prevent PHY jabbering during switch reset by inhibiting 415 416 * Tx on all ports and waiting for current packet to drain. ··· 419 418 rc = sja1105_inhibit_tx(priv, port_bitmap, true); 420 419 if (rc < 0) { 421 420 dev_err(dev, "Failed to inhibit Tx on ports\n"); 422 - return -ENXIO; 421 + rc = -ENXIO; 422 + goto out; 423 423 } 424 424 /* Wait for an eventual egress packet to finish transmission 425 425 * (reach IFG). It is guaranteed that a second one will not
+4 -2
drivers/net/ethernet/atheros/ag71xx.c
··· 526 526 struct device *dev = &ag->pdev->dev; 527 527 struct net_device *ndev = ag->ndev; 528 528 static struct mii_bus *mii_bus; 529 - struct device_node *np; 529 + struct device_node *np, *mnp; 530 530 int err; 531 531 532 532 np = dev->of_node; ··· 571 571 msleep(200); 572 572 } 573 573 574 - err = of_mdiobus_register(mii_bus, np); 574 + mnp = of_get_child_by_name(np, "mdio"); 575 + err = of_mdiobus_register(mii_bus, mnp); 576 + of_node_put(mnp); 575 577 if (err) 576 578 goto mdio_err_put_clk; 577 579
+6 -3
drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
··· 137 137 static int alloc_uld_rxqs(struct adapter *adap, 138 138 struct sge_uld_rxq_info *rxq_info, bool lro) 139 139 { 140 - struct sge *s = &adap->sge; 141 140 unsigned int nq = rxq_info->nrxq + rxq_info->nciq; 141 + int i, err, msi_idx, que_idx = 0, bmap_idx = 0; 142 142 struct sge_ofld_rxq *q = rxq_info->uldrxq; 143 143 unsigned short *ids = rxq_info->rspq_id; 144 - unsigned int bmap_idx = 0; 144 + struct sge *s = &adap->sge; 145 145 unsigned int per_chan; 146 - int i, err, msi_idx, que_idx = 0; 147 146 148 147 per_chan = rxq_info->nrxq / adap->params.nports; 149 148 ··· 160 161 161 162 if (msi_idx >= 0) { 162 163 bmap_idx = get_msix_idx_from_bmap(adap); 164 + if (bmap_idx < 0) { 165 + err = -ENOSPC; 166 + goto freeout; 167 + } 163 168 msi_idx = adap->msix_info_ulds[bmap_idx].idx; 164 169 } 165 170 err = t4_sge_alloc_rxq(adap, &q->rspq, false,
+5 -1
drivers/net/ethernet/hisilicon/hns_mdio.c
··· 148 148 { 149 149 u32 time_cnt; 150 150 u32 reg_value; 151 + int ret; 151 152 152 153 regmap_write(mdio_dev->subctrl_vbase, cfg_reg, set_val); 153 154 154 155 for (time_cnt = MDIO_TIMEOUT; time_cnt; time_cnt--) { 155 - regmap_read(mdio_dev->subctrl_vbase, st_reg, &reg_value); 156 + ret = regmap_read(mdio_dev->subctrl_vbase, st_reg, &reg_value); 157 + if (ret) 158 + return ret; 159 + 156 160 reg_value &= st_msk; 157 161 if ((!!check_st) == (!!reg_value)) 158 162 break;
+2 -1
drivers/net/ethernet/mellanox/mlx5/core/steering/dr_icm_pool.c
··· 137 137 138 138 icm_mr->icm_start_addr = icm_mr->dm.addr; 139 139 140 - align_diff = icm_mr->icm_start_addr % align_base; 140 + /* align_base is always a power of 2 */ 141 + align_diff = icm_mr->icm_start_addr & (align_base - 1); 141 142 if (align_diff) 142 143 icm_mr->used_length = align_base - align_diff; 143 144
+8 -6
drivers/net/ethernet/mscc/ocelot_board.c
··· 388 388 continue; 389 389 390 390 phy = of_phy_find_device(phy_node); 391 + of_node_put(phy_node); 391 392 if (!phy) 392 393 continue; 393 394 394 395 err = ocelot_probe_port(ocelot, port, regs, phy); 395 396 if (err) { 396 397 of_node_put(portnp); 397 - return err; 398 + goto out_put_ports; 398 399 } 399 400 400 401 phy_mode = of_get_phy_mode(portnp); ··· 423 422 "invalid phy mode for port%d, (Q)SGMII only\n", 424 423 port); 425 424 of_node_put(portnp); 426 - return -EINVAL; 425 + err = -EINVAL; 426 + goto out_put_ports; 427 427 } 428 428 429 429 serdes = devm_of_phy_get(ocelot->dev, portnp, NULL); ··· 437 435 "missing SerDes phys for port%d\n", 438 436 port); 439 437 440 - goto err_probe_ports; 438 + of_node_put(portnp); 439 + goto out_put_ports; 441 440 } 442 441 443 442 ocelot->ports[port]->serdes = serdes; ··· 450 447 451 448 dev_info(&pdev->dev, "Ocelot switch probed\n"); 452 449 453 - return 0; 454 - 455 - err_probe_ports: 450 + out_put_ports: 451 + of_node_put(ports); 456 452 return err; 457 453 } 458 454
+1
drivers/net/ethernet/pensando/Kconfig
··· 20 20 config IONIC 21 21 tristate "Pensando Ethernet IONIC Support" 22 22 depends on 64BIT && PCI 23 + select NET_DEVLINK 23 24 help 24 25 This enables the support for the Pensando family of Ethernet 25 26 adapters. More specific information on this driver can be
+1
drivers/net/ethernet/qlogic/qla3xxx.c
··· 2787 2787 netdev_err(qdev->ndev, 2788 2788 "PCI mapping failed with error: %d\n", 2789 2789 err); 2790 + dev_kfree_skb_irq(skb); 2790 2791 ql_free_large_buffers(qdev); 2791 2792 return -ENOMEM; 2792 2793 }
+7 -23
drivers/net/ethernet/socionext/netsec.c
··· 282 282 void *vaddr; 283 283 u16 head, tail; 284 284 u16 xdp_xmit; /* netsec_xdp_xmit packets */ 285 - bool is_xdp; 286 285 struct page_pool *page_pool; 287 286 struct xdp_rxq_info xdp_rxq; 288 287 spinlock_t lock; /* XDP tx queue locking */ ··· 633 634 unsigned int bytes; 634 635 int cnt = 0; 635 636 636 - if (dring->is_xdp) 637 - spin_lock(&dring->lock); 637 + spin_lock(&dring->lock); 638 638 639 639 bytes = 0; 640 640 entry = dring->vaddr + DESC_SZ * tail; ··· 680 682 entry = dring->vaddr + DESC_SZ * tail; 681 683 cnt++; 682 684 } 683 - if (dring->is_xdp) 684 - spin_unlock(&dring->lock); 685 + 686 + spin_unlock(&dring->lock); 685 687 686 688 if (!cnt) 687 689 return false; ··· 797 799 de->data_buf_addr_lw = lower_32_bits(desc->dma_addr); 798 800 de->buf_len_info = (tx_ctrl->tcp_seg_len << 16) | desc->len; 799 801 de->attr = attr; 800 - /* under spin_lock if using XDP */ 801 - if (!dring->is_xdp) 802 - dma_wmb(); 803 802 804 803 dring->desc[idx] = *desc; 805 804 if (desc->buf_type == TYPE_NETSEC_SKB) ··· 1118 1123 u16 tso_seg_len = 0; 1119 1124 int filled; 1120 1125 1121 - if (dring->is_xdp) 1122 - spin_lock_bh(&dring->lock); 1126 + spin_lock_bh(&dring->lock); 1123 1127 filled = netsec_desc_used(dring); 1124 1128 if (netsec_check_stop_tx(priv, filled)) { 1125 - if (dring->is_xdp) 1126 - spin_unlock_bh(&dring->lock); 1129 + spin_unlock_bh(&dring->lock); 1127 1130 net_warn_ratelimited("%s %s Tx queue full\n", 1128 1131 dev_name(priv->dev), ndev->name); 1129 1132 return NETDEV_TX_BUSY; ··· 1154 1161 tx_desc.dma_addr = dma_map_single(priv->dev, skb->data, 1155 1162 skb_headlen(skb), DMA_TO_DEVICE); 1156 1163 if (dma_mapping_error(priv->dev, tx_desc.dma_addr)) { 1157 - if (dring->is_xdp) 1158 - spin_unlock_bh(&dring->lock); 1164 + spin_unlock_bh(&dring->lock); 1159 1165 netif_err(priv, drv, priv->ndev, 1160 1166 "%s: DMA mapping failed\n", __func__); 1161 1167 ndev->stats.tx_dropped++; ··· 1169 1177 netdev_sent_queue(priv->ndev, skb->len); 1170 1178 1171 1179 netsec_set_tx_de(priv, dring, &tx_ctrl, &tx_desc, skb); 1172 - if (dring->is_xdp) 1173 - spin_unlock_bh(&dring->lock); 1180 + spin_unlock_bh(&dring->lock); 1174 1181 netsec_write(priv, NETSEC_REG_NRM_TX_PKTCNT, 1); /* submit another tx */ 1175 1182 1176 1183 return NETDEV_TX_OK; ··· 1253 1262 static void netsec_setup_tx_dring(struct netsec_priv *priv) 1254 1263 { 1255 1264 struct netsec_desc_ring *dring = &priv->desc_ring[NETSEC_RING_TX]; 1256 - struct bpf_prog *xdp_prog = READ_ONCE(priv->xdp_prog); 1257 1265 int i; 1258 1266 1259 1267 for (i = 0; i < DESC_NUM; i++) { ··· 1265 1275 */ 1266 1276 de->attr = 1U << NETSEC_TX_SHIFT_OWN_FIELD; 1267 1277 } 1268 - 1269 - if (xdp_prog) 1270 - dring->is_xdp = true; 1271 - else 1272 - dring->is_xdp = false; 1273 - 1274 1278 } 1275 1279 1276 1280 static int netsec_setup_rx_dring(struct netsec_priv *priv)
+7 -6
drivers/net/ethernet/stmicro/stmmac/dwmac4_core.c
··· 401 401 int numhashregs = (hw->multicast_filter_bins >> 5); 402 402 int mcbitslog2 = hw->mcast_bits_log2; 403 403 unsigned int value; 404 + u32 mc_filter[8]; 404 405 int i; 406 + 407 + memset(mc_filter, 0, sizeof(mc_filter)); 405 408 406 409 value = readl(ioaddr + GMAC_PACKET_FILTER); 407 410 value &= ~GMAC_PACKET_FILTER_HMC; ··· 419 416 /* Pass all multi */ 420 417 value |= GMAC_PACKET_FILTER_PM; 421 418 /* Set all the bits of the HASH tab */ 422 - for (i = 0; i < numhashregs; i++) 423 - writel(0xffffffff, ioaddr + GMAC_HASH_TAB(i)); 419 + memset(mc_filter, 0xff, sizeof(mc_filter)); 424 420 } else if (!netdev_mc_empty(dev)) { 425 421 struct netdev_hw_addr *ha; 426 - u32 mc_filter[8]; 427 422 428 423 /* Hash filter for multicast */ 429 424 value |= GMAC_PACKET_FILTER_HMC; 430 425 431 - memset(mc_filter, 0, sizeof(mc_filter)); 432 426 netdev_for_each_mc_addr(ha, dev) { 433 427 /* The upper n bits of the calculated CRC are used to 434 428 * index the contents of the hash table. The number of ··· 440 440 */ 441 441 mc_filter[bit_nr >> 5] |= (1 << (bit_nr & 0x1f)); 442 442 } 443 - for (i = 0; i < numhashregs; i++) 444 - writel(mc_filter[i], ioaddr + GMAC_HASH_TAB(i)); 445 443 } 444 + 445 + for (i = 0; i < numhashregs; i++) 446 + writel(mc_filter[i], ioaddr + GMAC_HASH_TAB(i)); 446 447 447 448 value |= GMAC_PACKET_FILTER_HPF; 448 449
+2 -1
drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h
··· 84 84 #define XGMAC_TSIE BIT(12) 85 85 #define XGMAC_LPIIE BIT(5) 86 86 #define XGMAC_PMTIE BIT(4) 87 - #define XGMAC_INT_DEFAULT_EN (XGMAC_LPIIE | XGMAC_PMTIE | XGMAC_TSIE) 87 + #define XGMAC_INT_DEFAULT_EN (XGMAC_LPIIE | XGMAC_PMTIE) 88 88 #define XGMAC_Qx_TX_FLOW_CTRL(x) (0x00000070 + (x) * 4) 89 89 #define XGMAC_PT GENMASK(31, 16) 90 90 #define XGMAC_PT_SHIFT 16 ··· 122 122 #define XGMAC_HWFEAT_GMIISEL BIT(1) 123 123 #define XGMAC_HW_FEATURE1 0x00000120 124 124 #define XGMAC_HWFEAT_L3L4FNUM GENMASK(30, 27) 125 + #define XGMAC_HWFEAT_HASHTBLSZ GENMASK(25, 24) 125 126 #define XGMAC_HWFEAT_RSSEN BIT(20) 126 127 #define XGMAC_HWFEAT_TSOEN BIT(18) 127 128 #define XGMAC_HWFEAT_SPHEN BIT(17)
+5 -4
drivers/net/ethernet/stmicro/stmmac/dwxgmac2_core.c
··· 472 472 dwxgmac2_set_mchash(ioaddr, mc_filter, mcbitslog2); 473 473 474 474 /* Handle multiple unicast addresses */ 475 - if (netdev_uc_count(dev) > XGMAC_ADDR_MAX) { 475 + if (netdev_uc_count(dev) > hw->unicast_filter_entries) { 476 476 value |= XGMAC_FILTER_PR; 477 477 } else { 478 478 struct netdev_hw_addr *ha; ··· 523 523 struct stmmac_rss *cfg, u32 num_rxq) 524 524 { 525 525 void __iomem *ioaddr = hw->pcsr; 526 + u32 value, *key; 526 527 int i, ret; 527 - u32 value; 528 528 529 529 value = readl(ioaddr + XGMAC_RSS_CTRL); 530 530 if (!cfg || !cfg->enable) { ··· 533 533 return 0; 534 534 } 535 535 536 - for (i = 0; i < (sizeof(cfg->key) / sizeof(u32)); i++) { 537 - ret = dwxgmac2_rss_write_reg(ioaddr, true, i, cfg->key[i]); 536 + key = (u32 *)cfg->key; 537 + for (i = 0; i < (ARRAY_SIZE(cfg->key) / sizeof(u32)); i++) { 538 + ret = dwxgmac2_rss_write_reg(ioaddr, true, i, key[i]); 538 539 if (ret) 539 540 return ret; 540 541 }
+1
drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
··· 380 380 /* MAC HW feature 1 */ 381 381 hw_cap = readl(ioaddr + XGMAC_HW_FEATURE1); 382 382 dma_cap->l3l4fnum = (hw_cap & XGMAC_HWFEAT_L3L4FNUM) >> 27; 383 + dma_cap->hash_tb_sz = (hw_cap & XGMAC_HWFEAT_HASHTBLSZ) >> 24; 383 384 dma_cap->rssen = (hw_cap & XGMAC_HWFEAT_RSSEN) >> 20; 384 385 dma_cap->tsoen = (hw_cap & XGMAC_HWFEAT_TSOEN) >> 18; 385 386 dma_cap->sphen = (hw_cap & XGMAC_HWFEAT_SPHEN) >> 17;
+17 -8
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
··· 629 629 config.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT; 630 630 ptp_v2 = PTP_TCR_TSVER2ENA; 631 631 snap_type_sel = PTP_TCR_SNAPTYPSEL_1; 632 + ts_event_en = PTP_TCR_TSEVNTENA; 632 633 ptp_over_ipv4_udp = PTP_TCR_TSIPV4ENA; 633 634 ptp_over_ipv6_udp = PTP_TCR_TSIPV6ENA; 634 635 ptp_over_ethernet = PTP_TCR_TSIPENA; ··· 4716 4715 if (!ndev || !netif_running(ndev)) 4717 4716 return 0; 4718 4717 4719 - mutex_lock(&priv->lock); 4718 + phylink_mac_change(priv->phylink, false); 4720 4719 4721 - rtnl_lock(); 4722 - phylink_stop(priv->phylink); 4723 - rtnl_unlock(); 4720 + mutex_lock(&priv->lock); 4724 4721 4725 4722 netif_device_detach(ndev); 4726 4723 stmmac_stop_all_queues(priv); ··· 4733 4734 stmmac_pmt(priv, priv->hw, priv->wolopts); 4734 4735 priv->irq_wake = 1; 4735 4736 } else { 4737 + mutex_unlock(&priv->lock); 4738 + rtnl_lock(); 4739 + phylink_stop(priv->phylink); 4740 + rtnl_unlock(); 4741 + mutex_lock(&priv->lock); 4742 + 4736 4743 stmmac_mac_set(priv, priv->ioaddr, false); 4737 4744 pinctrl_pm_select_sleep_state(priv->device); 4738 4745 /* Disable clock in case of PWM is off */ ··· 4829 4824 4830 4825 stmmac_start_all_queues(priv); 4831 4826 4832 - rtnl_lock(); 4833 - phylink_start(priv->phylink); 4834 - rtnl_unlock(); 4835 - 4836 4827 mutex_unlock(&priv->lock); 4828 + 4829 + if (!device_may_wakeup(priv->device)) { 4830 + rtnl_lock(); 4831 + phylink_start(priv->phylink); 4832 + rtnl_unlock(); 4833 + } 4834 + 4835 + phylink_mac_change(priv->phylink, true); 4837 4836 4838 4837 return 0; 4839 4838 }
-4
drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c
··· 1564 1564 struct stmmac_packet_attrs attr = { }; 1565 1565 int size = priv->dma_buf_sz; 1566 1566 1567 - /* Only XGMAC has SW support for multiple RX descs in same packet */ 1568 - if (priv->plat->has_xgmac) 1569 - size = priv->dev->max_mtu; 1570 - 1571 1567 attr.dst = priv->dev->dev_addr; 1572 1568 attr.max_size = size - ETH_FCS_LEN; 1573 1569 attr.queue_mapping = queue;
+2 -1
drivers/net/ieee802154/atusb.c
··· 1137 1137 1138 1138 ieee802154_unregister_hw(atusb->hw); 1139 1139 1140 + usb_put_dev(atusb->usb_dev); 1141 + 1140 1142 ieee802154_free_hw(atusb->hw); 1141 1143 1142 1144 usb_set_intfdata(interface, NULL); 1143 - usb_put_dev(atusb->usb_dev); 1144 1145 1145 1146 pr_debug("%s done\n", __func__); 1146 1147 }
+1 -1
drivers/net/ieee802154/ca8210.c
··· 3145 3145 goto error; 3146 3146 } 3147 3147 3148 + priv->spi->dev.platform_data = pdata; 3148 3149 ret = ca8210_get_platform_data(priv->spi, pdata); 3149 3150 if (ret) { 3150 3151 dev_crit(&spi_device->dev, "ca8210_get_platform_data failed\n"); 3151 3152 goto error; 3152 3153 } 3153 - priv->spi->dev.platform_data = pdata; 3154 3154 3155 3155 ret = ca8210_dev_com_init(priv); 3156 3156 if (ret) {
+1 -1
drivers/net/ieee802154/mcr20a.c
··· 800 800 if (!skb) 801 801 return; 802 802 803 - memcpy(skb_put(skb, len), lp->rx_buf, len); 803 + __skb_put_data(skb, lp->rx_buf, len); 804 804 ieee802154_rx_irqsafe(lp->hw, skb, lp->rx_lqi[0]); 805 805 806 806 print_hex_dump_debug("mcr20a rx: ", DUMP_PREFIX_OFFSET, 16, 1,
+69
drivers/net/phy/at803x.c
··· 15 15 #include <linux/of_gpio.h> 16 16 #include <linux/gpio/consumer.h> 17 17 18 + #define AT803X_SPECIFIC_STATUS 0x11 19 + #define AT803X_SS_SPEED_MASK (3 << 14) 20 + #define AT803X_SS_SPEED_1000 (2 << 14) 21 + #define AT803X_SS_SPEED_100 (1 << 14) 22 + #define AT803X_SS_SPEED_10 (0 << 14) 23 + #define AT803X_SS_DUPLEX BIT(13) 24 + #define AT803X_SS_SPEED_DUPLEX_RESOLVED BIT(11) 25 + #define AT803X_SS_MDIX BIT(6) 26 + 18 27 #define AT803X_INTR_ENABLE 0x12 19 28 #define AT803X_INTR_ENABLE_AUTONEG_ERR BIT(15) 20 29 #define AT803X_INTR_ENABLE_SPEED_CHANGED BIT(14) ··· 366 357 return aneg_done; 367 358 } 368 359 360 + static int at803x_read_status(struct phy_device *phydev) 361 + { 362 + int ss, err, old_link = phydev->link; 363 + 364 + /* Update the link, but return if there was an error */ 365 + err = genphy_update_link(phydev); 366 + if (err) 367 + return err; 368 + 369 + /* why bother the PHY if nothing can have changed */ 370 + if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) 371 + return 0; 372 + 373 + phydev->speed = SPEED_UNKNOWN; 374 + phydev->duplex = DUPLEX_UNKNOWN; 375 + phydev->pause = 0; 376 + phydev->asym_pause = 0; 377 + 378 + err = genphy_read_lpa(phydev); 379 + if (err < 0) 380 + return err; 381 + 382 + /* Read the AT8035 PHY-Specific Status register, which indicates the 383 + * speed and duplex that the PHY is actually using, irrespective of 384 + * whether we are in autoneg mode or not. 385 + */ 386 + ss = phy_read(phydev, AT803X_SPECIFIC_STATUS); 387 + if (ss < 0) 388 + return ss; 389 + 390 + if (ss & AT803X_SS_SPEED_DUPLEX_RESOLVED) { 391 + switch (ss & AT803X_SS_SPEED_MASK) { 392 + case AT803X_SS_SPEED_10: 393 + phydev->speed = SPEED_10; 394 + break; 395 + case AT803X_SS_SPEED_100: 396 + phydev->speed = SPEED_100; 397 + break; 398 + case AT803X_SS_SPEED_1000: 399 + phydev->speed = SPEED_1000; 400 + break; 401 + } 402 + if (ss & AT803X_SS_DUPLEX) 403 + phydev->duplex = DUPLEX_FULL; 404 + else 405 + phydev->duplex = DUPLEX_HALF; 406 + if (ss & AT803X_SS_MDIX) 407 + phydev->mdix = ETH_TP_MDI_X; 408 + else 409 + phydev->mdix = ETH_TP_MDI; 410 + } 411 + 412 + if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) 413 + phy_resolve_aneg_pause(phydev); 414 + 415 + return 0; 416 + } 417 + 369 418 static struct phy_driver at803x_driver[] = { 370 419 { 371 420 /* ATHEROS 8035 */ ··· 437 370 .suspend = at803x_suspend, 438 371 .resume = at803x_resume, 439 372 /* PHY_GBIT_FEATURES */ 373 + .read_status = at803x_read_status, 440 374 .ack_interrupt = at803x_ack_interrupt, 441 375 .config_intr = at803x_config_intr, 442 376 }, { ··· 467 399 .suspend = at803x_suspend, 468 400 .resume = at803x_resume, 469 401 /* PHY_GBIT_FEATURES */ 402 + .read_status = at803x_read_status, 470 403 .aneg_done = at803x_aneg_done, 471 404 .ack_interrupt = &at803x_ack_interrupt, 472 405 .config_intr = &at803x_config_intr,
+1 -1
drivers/net/phy/mdio_device.c
··· 121 121 return; 122 122 123 123 if (mdiodev->reset_gpio) 124 - gpiod_set_value(mdiodev->reset_gpio, value); 124 + gpiod_set_value_cansleep(mdiodev->reset_gpio, value); 125 125 126 126 if (mdiodev->reset_ctrl) { 127 127 if (value)
+13 -7
drivers/net/phy/phy-core.c
··· 283 283 phydev->eee_broken_modes = broken; 284 284 } 285 285 286 + void phy_resolve_aneg_pause(struct phy_device *phydev) 287 + { 288 + if (phydev->duplex == DUPLEX_FULL) { 289 + phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 290 + phydev->lp_advertising); 291 + phydev->asym_pause = linkmode_test_bit( 292 + ETHTOOL_LINK_MODE_Asym_Pause_BIT, 293 + phydev->lp_advertising); 294 + } 295 + } 296 + EXPORT_SYMBOL_GPL(phy_resolve_aneg_pause); 297 + 286 298 /** 287 299 * phy_resolve_aneg_linkmode - resolve the advertisements into phy settings 288 300 * @phydev: The phy_device struct ··· 317 305 break; 318 306 } 319 307 320 - if (phydev->duplex == DUPLEX_FULL) { 321 - phydev->pause = linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 322 - phydev->lp_advertising); 323 - phydev->asym_pause = linkmode_test_bit( 324 - ETHTOOL_LINK_MODE_Asym_Pause_BIT, 325 - phydev->lp_advertising); 326 - } 308 + phy_resolve_aneg_pause(phydev); 327 309 } 328 310 EXPORT_SYMBOL_GPL(phy_resolve_aneg_linkmode); 329 311
+5
drivers/net/phy/phy.c
··· 457 457 val); 458 458 change_autoneg = true; 459 459 break; 460 + case MII_CTRL1000: 461 + mii_ctrl1000_mod_linkmode_adv_t(phydev->advertising, 462 + val); 463 + change_autoneg = true; 464 + break; 460 465 default: 461 466 /* do nothing */ 462 467 break;
+40 -25
drivers/net/phy/phy_device.c
··· 1783 1783 } 1784 1784 EXPORT_SYMBOL(genphy_update_link); 1785 1785 1786 - /** 1787 - * genphy_read_status - check the link status and update current link state 1788 - * @phydev: target phy_device struct 1789 - * 1790 - * Description: Check the link, then figure out the current state 1791 - * by comparing what we advertise with what the link partner 1792 - * advertises. Start by checking the gigabit possibilities, 1793 - * then move on to 10/100. 1794 - */ 1795 - int genphy_read_status(struct phy_device *phydev) 1786 + int genphy_read_lpa(struct phy_device *phydev) 1796 1787 { 1797 - int lpa, lpagb, err, old_link = phydev->link; 1798 - 1799 - /* Update the link, but return if there was an error */ 1800 - err = genphy_update_link(phydev); 1801 - if (err) 1802 - return err; 1803 - 1804 - /* why bother the PHY if nothing can have changed */ 1805 - if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) 1806 - return 0; 1807 - 1808 - phydev->speed = SPEED_UNKNOWN; 1809 - phydev->duplex = DUPLEX_UNKNOWN; 1810 - phydev->pause = 0; 1811 - phydev->asym_pause = 0; 1788 + int lpa, lpagb; 1812 1789 1813 1790 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) { 1814 1791 if (phydev->is_gigabit_capable) { ··· 1815 1838 return lpa; 1816 1839 1817 1840 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa); 1841 + } 1842 + 1843 + return 0; 1844 + } 1845 + EXPORT_SYMBOL(genphy_read_lpa); 1846 + 1847 + /** 1848 + * genphy_read_status - check the link status and update current link state 1849 + * @phydev: target phy_device struct 1850 + * 1851 + * Description: Check the link, then figure out the current state 1852 + * by comparing what we advertise with what the link partner 1853 + * advertises. Start by checking the gigabit possibilities, 1854 + * then move on to 10/100. 1855 + */ 1856 + int genphy_read_status(struct phy_device *phydev) 1857 + { 1858 + int err, old_link = phydev->link; 1859 + 1860 + /* Update the link, but return if there was an error */ 1861 + err = genphy_update_link(phydev); 1862 + if (err) 1863 + return err; 1864 + 1865 + /* why bother the PHY if nothing can have changed */ 1866 + if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) 1867 + return 0; 1868 + 1869 + phydev->speed = SPEED_UNKNOWN; 1870 + phydev->duplex = DUPLEX_UNKNOWN; 1871 + phydev->pause = 0; 1872 + phydev->asym_pause = 0; 1873 + 1874 + err = genphy_read_lpa(phydev); 1875 + if (err < 0) 1876 + return err; 1877 + 1878 + if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) { 1818 1879 phy_resolve_aneg_linkmode(phydev); 1819 1880 } else if (phydev->autoneg == AUTONEG_DISABLE) { 1820 1881 int bmcr = phy_read(phydev, MII_BMCR);
+2 -2
drivers/net/ppp/pptp.c
··· 238 238 skb_dst_drop(skb); 239 239 skb_dst_set(skb, &rt->dst); 240 240 241 - nf_reset(skb); 241 + nf_reset_ct(skb); 242 242 243 243 skb->ip_summed = CHECKSUM_NONE; 244 244 ip_select_ident(net, skb, NULL); ··· 358 358 po = lookup_chan(htons(header->call_id), iph->saddr); 359 359 if (po) { 360 360 skb_dst_drop(skb); 361 - nf_reset(skb); 361 + nf_reset_ct(skb); 362 362 return sk_receive_skb(sk_pppox(po), skb, 0); 363 363 } 364 364 drop:
+1 -1
drivers/net/tun.c
··· 1104 1104 */ 1105 1105 skb_orphan(skb); 1106 1106 1107 - nf_reset(skb); 1107 + nf_reset_ct(skb); 1108 1108 1109 1109 if (ptr_ring_produce(&tfile->tx_ring, skb)) 1110 1110 goto drop;
+8 -4
drivers/net/usb/hso.c
··· 2620 2620 */ 2621 2621 if (serial->tiocmget) { 2622 2622 tiocmget = serial->tiocmget; 2623 + tiocmget->endp = hso_get_ep(interface, 2624 + USB_ENDPOINT_XFER_INT, 2625 + USB_DIR_IN); 2626 + if (!tiocmget->endp) { 2627 + dev_err(&interface->dev, "Failed to find INT IN ep\n"); 2628 + goto exit; 2629 + } 2630 + 2623 2631 tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL); 2624 2632 if (tiocmget->urb) { 2625 2633 mutex_init(&tiocmget->mutex); 2626 2634 init_waitqueue_head(&tiocmget->waitq); 2627 - tiocmget->endp = hso_get_ep( 2628 - interface, 2629 - USB_ENDPOINT_XFER_INT, 2630 - USB_DIR_IN); 2631 2635 } else 2632 2636 hso_free_tiomget(serial); 2633 2637 }
+1
drivers/net/usb/qmi_wwan.c
··· 1350 1350 {QMI_FIXED_INTF(0x1e2d, 0x0082, 4)}, /* Cinterion PHxx,PXxx (2 RmNet) */ 1351 1351 {QMI_FIXED_INTF(0x1e2d, 0x0082, 5)}, /* Cinterion PHxx,PXxx (2 RmNet) */ 1352 1352 {QMI_FIXED_INTF(0x1e2d, 0x0083, 4)}, /* Cinterion PHxx,PXxx (1 RmNet + USB Audio)*/ 1353 + {QMI_QUIRK_SET_DTR(0x1e2d, 0x00b0, 4)}, /* Cinterion CLS8 */ 1353 1354 {QMI_FIXED_INTF(0x413c, 0x81a2, 8)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */ 1354 1355 {QMI_FIXED_INTF(0x413c, 0x81a3, 8)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */ 1355 1356 {QMI_FIXED_INTF(0x413c, 0x81a4, 8)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */
+1 -2
drivers/net/usb/r8152.c
··· 4799 4799 struct r8152 *tp = usb_get_intfdata(intf); 4800 4800 4801 4801 clear_bit(SELECTIVE_SUSPEND, &tp->flags); 4802 - mutex_lock(&tp->control); 4803 4802 tp->rtl_ops.init(tp); 4804 4803 queue_delayed_work(system_long_wq, &tp->hw_phy_work, 0); 4805 - mutex_unlock(&tp->control); 4804 + set_ethernet_addr(tp); 4806 4805 return rtl8152_resume(intf); 4807 4806 } 4808 4807
+1 -1
drivers/net/virtio_net.c
··· 1585 1585 /* Don't wait up for transmitted skbs to be freed. */ 1586 1586 if (!use_napi) { 1587 1587 skb_orphan(skb); 1588 - nf_reset(skb); 1588 + nf_reset_ct(skb); 1589 1589 } 1590 1590 1591 1591 /* If running out of space, stop queue to avoid getting packets that we
+4 -4
drivers/net/vrf.c
··· 366 366 struct neighbour *neigh; 367 367 int ret; 368 368 369 - nf_reset(skb); 369 + nf_reset_ct(skb); 370 370 371 371 skb->protocol = htons(ETH_P_IPV6); 372 372 skb->dev = dev; ··· 459 459 460 460 /* reset skb device */ 461 461 if (likely(err == 1)) 462 - nf_reset(skb); 462 + nf_reset_ct(skb); 463 463 else 464 464 skb = NULL; 465 465 ··· 560 560 bool is_v6gw = false; 561 561 int ret = -EINVAL; 562 562 563 - nf_reset(skb); 563 + nf_reset_ct(skb); 564 564 565 565 /* Be paranoid, rather than too clever. */ 566 566 if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) { ··· 670 670 671 671 /* reset skb device */ 672 672 if (likely(err == 1)) 673 - nf_reset(skb); 673 + nf_reset_ct(skb); 674 674 else 675 675 skb = NULL; 676 676
+2 -2
drivers/net/wireless/mac80211_hwsim.c
··· 1261 1261 skb_orphan(skb); 1262 1262 skb_dst_drop(skb); 1263 1263 skb->mark = 0; 1264 - secpath_reset(skb); 1265 - nf_reset(skb); 1264 + skb_ext_reset(skb); 1265 + nf_reset_ct(skb); 1266 1266 1267 1267 /* 1268 1268 * Get absolute mactime here so all HWs RX at the "same time", and
+9 -8
drivers/net/xen-netfront.c
··· 887 887 return 0; 888 888 } 889 889 890 - static RING_IDX xennet_fill_frags(struct netfront_queue *queue, 891 - struct sk_buff *skb, 892 - struct sk_buff_head *list) 890 + static int xennet_fill_frags(struct netfront_queue *queue, 891 + struct sk_buff *skb, 892 + struct sk_buff_head *list) 893 893 { 894 894 RING_IDX cons = queue->rx.rsp_cons; 895 895 struct sk_buff *nskb; ··· 908 908 if (unlikely(skb_shinfo(skb)->nr_frags >= MAX_SKB_FRAGS)) { 909 909 queue->rx.rsp_cons = ++cons + skb_queue_len(list); 910 910 kfree_skb(nskb); 911 - return ~0U; 911 + return -ENOENT; 912 912 } 913 913 914 914 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, ··· 919 919 kfree_skb(nskb); 920 920 } 921 921 922 - return cons; 922 + queue->rx.rsp_cons = cons; 923 + 924 + return 0; 923 925 } 924 926 925 927 static int checksum_setup(struct net_device *dev, struct sk_buff *skb) ··· 1047 1045 skb->data_len = rx->status; 1048 1046 skb->len += rx->status; 1049 1047 1050 - i = xennet_fill_frags(queue, skb, &tmpq); 1051 - if (unlikely(i == ~0U)) 1048 + if (unlikely(xennet_fill_frags(queue, skb, &tmpq))) 1052 1049 goto err; 1053 1050 1054 1051 if (rx->flags & XEN_NETRXF_csum_blank) ··· 1057 1056 1058 1057 __skb_queue_tail(&rxq, skb); 1059 1058 1060 - queue->rx.rsp_cons = ++i; 1059 + i = ++queue->rx.rsp_cons; 1061 1060 work_done++; 1062 1061 } 1063 1062
+2 -1
drivers/ptp/ptp_qoriq.c
··· 507 507 ptp_qoriq->regs.etts_regs = base + ETTS_REGS_OFFSET; 508 508 } 509 509 510 + spin_lock_init(&ptp_qoriq->lock); 511 + 510 512 ktime_get_real_ts64(&now); 511 513 ptp_qoriq_settime(&ptp_qoriq->caps, &now); 512 514 ··· 516 514 (ptp_qoriq->tclk_period & TCLK_PERIOD_MASK) << TCLK_PERIOD_SHIFT | 517 515 (ptp_qoriq->cksel & CKSEL_MASK) << CKSEL_SHIFT; 518 516 519 - spin_lock_init(&ptp_qoriq->lock); 520 517 spin_lock_irqsave(&ptp_qoriq->lock, flags); 521 518 522 519 regs = &ptp_qoriq->regs;
+2 -4
drivers/staging/octeon/ethernet-tx.c
··· 349 349 */ 350 350 dst_release(skb_dst(skb)); 351 351 skb_dst_set(skb, NULL); 352 - #ifdef CONFIG_XFRM 353 - secpath_reset(skb); 354 - #endif 355 - nf_reset(skb); 352 + skb_ext_reset(skb); 353 + nf_reset_ct(skb); 356 354 357 355 #ifdef CONFIG_NET_SCHED 358 356 skb->tc_index = 0;
+3 -1
include/linux/dsa/sja1105.h
··· 31 31 #define SJA1105_META_SMAC 0x222222222222ull 32 32 #define SJA1105_META_DMAC 0x0180C200000Eull 33 33 34 + #define SJA1105_HWTS_RX_EN 0 35 + 34 36 /* Global tagger data: each struct sja1105_port has a reference to 35 37 * the structure defined in struct sja1105_private. 36 38 */ ··· 44 42 * from taggers running on multiple ports on SMP systems 45 43 */ 46 44 spinlock_t meta_lock; 47 - bool hwts_rx_en; 45 + unsigned long state; 48 46 }; 49 47 50 48 struct sja1105_skb_cb {
+9
include/linux/mii.h
··· 455 455 lp_advertising, lpa & LPA_LPACK); 456 456 } 457 457 458 + static inline void mii_ctrl1000_mod_linkmode_adv_t(unsigned long *advertising, 459 + u32 ctrl1000) 460 + { 461 + linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, advertising, 462 + ctrl1000 & ADVERTISE_1000HALF); 463 + linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, advertising, 464 + ctrl1000 & ADVERTISE_1000FULL); 465 + } 466 + 458 467 /** 459 468 * linkmode_adv_to_lcl_adv_t 460 469 * @advertising:pointer to linkmode advertising
+2
include/linux/phy.h
··· 678 678 return phydev->state >= PHY_UP; 679 679 } 680 680 681 + void phy_resolve_aneg_pause(struct phy_device *phydev); 681 682 void phy_resolve_aneg_linkmode(struct phy_device *phydev); 682 683 683 684 /** ··· 1077 1076 int __genphy_config_aneg(struct phy_device *phydev, bool changed); 1078 1077 int genphy_aneg_done(struct phy_device *phydev); 1079 1078 int genphy_update_link(struct phy_device *phydev); 1079 + int genphy_read_lpa(struct phy_device *phydev); 1080 1080 int genphy_read_status(struct phy_device *phydev); 1081 1081 int genphy_suspend(struct phy_device *phydev); 1082 1082 int genphy_resume(struct phy_device *phydev);
+1 -4
include/linux/skbuff.h
··· 4160 4160 static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *s) {} 4161 4161 #endif /* CONFIG_SKB_EXTENSIONS */ 4162 4162 4163 - static inline void nf_reset(struct sk_buff *skb) 4163 + static inline void nf_reset_ct(struct sk_buff *skb) 4164 4164 { 4165 4165 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE) 4166 4166 nf_conntrack_put(skb_nfct(skb)); 4167 4167 skb->_nfct = 0; 4168 - #endif 4169 - #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) 4170 - skb_ext_del(skb, SKB_EXT_BRIDGE_NF); 4171 4168 #endif 4172 4169 } 4173 4170
+1 -1
include/trace/events/rxrpc.h
··· 1068 1068 ), 1069 1069 1070 1070 TP_fast_assign( 1071 - __entry->call = call->debug_id; 1071 + __entry->call = call ? call->debug_id : 0; 1072 1072 __entry->why = why; 1073 1073 __entry->seq = seq; 1074 1074 __entry->offset = offset;
+2 -2
lib/textsearch.c
··· 89 89 * goto errout; 90 90 * } 91 91 * 92 - * pos = textsearch_find_continuous(conf, \&state, example, strlen(example)); 92 + * pos = textsearch_find_continuous(conf, &state, example, strlen(example)); 93 93 * if (pos != UINT_MAX) 94 - * panic("Oh my god, dancing chickens at \%d\n", pos); 94 + * panic("Oh my god, dancing chickens at %d\n", pos); 95 95 * 96 96 * textsearch_destroy(conf); 97 97 */
+1 -1
net/batman-adv/soft-interface.c
··· 436 436 /* clean the netfilter state now that the batman-adv header has been 437 437 * removed 438 438 */ 439 - nf_reset(skb); 439 + nf_reset_ct(skb); 440 440 441 441 if (unlikely(!pskb_may_pull(skb, ETH_HLEN))) 442 442 goto dropped;
+3 -3
net/core/devlink.c
··· 3172 3172 NETLINK_CB(cb->skb).portid, 3173 3173 cb->nlh->nlmsg_seq, 3174 3174 NLM_F_MULTI); 3175 - if (err) { 3175 + if (err && err != -EOPNOTSUPP) { 3176 3176 mutex_unlock(&devlink->lock); 3177 3177 goto out; 3178 3178 } ··· 3432 3432 NETLINK_CB(cb->skb).portid, 3433 3433 cb->nlh->nlmsg_seq, 3434 3434 NLM_F_MULTI); 3435 - if (err) { 3435 + if (err && err != -EOPNOTSUPP) { 3436 3436 mutex_unlock(&devlink->lock); 3437 3437 goto out; 3438 3438 } ··· 4088 4088 cb->nlh->nlmsg_seq, NLM_F_MULTI, 4089 4089 cb->extack); 4090 4090 mutex_unlock(&devlink->lock); 4091 - if (err) 4091 + if (err && err != -EOPNOTSUPP) 4092 4092 break; 4093 4093 idx++; 4094 4094 }
+1 -1
net/core/skbuff.c
··· 5120 5120 skb->ignore_df = 0; 5121 5121 skb_dst_drop(skb); 5122 5122 skb_ext_reset(skb); 5123 - nf_reset(skb); 5123 + nf_reset_ct(skb); 5124 5124 nf_reset_trace(skb); 5125 5125 5126 5126 #ifdef CONFIG_NET_SWITCHDEV
+9 -4
net/core/sock.c
··· 1700 1700 sk_filter_uncharge(sk, filter); 1701 1701 RCU_INIT_POINTER(sk->sk_filter, NULL); 1702 1702 } 1703 - if (rcu_access_pointer(sk->sk_reuseport_cb)) 1704 - reuseport_detach_sock(sk); 1705 1703 1706 1704 sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP); 1707 1705 ··· 1726 1728 1727 1729 void sk_destruct(struct sock *sk) 1728 1730 { 1729 - if (sock_flag(sk, SOCK_RCU_FREE)) 1731 + bool use_call_rcu = sock_flag(sk, SOCK_RCU_FREE); 1732 + 1733 + if (rcu_access_pointer(sk->sk_reuseport_cb)) { 1734 + reuseport_detach_sock(sk); 1735 + use_call_rcu = true; 1736 + } 1737 + 1738 + if (use_call_rcu) 1730 1739 call_rcu(&sk->sk_rcu, __sk_destruct); 1731 1740 else 1732 1741 __sk_destruct(&sk->sk_rcu); ··· 3497 3492 return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L; 3498 3493 } 3499 3494 3500 - static char *sock_prot_memory_pressure(struct proto *proto) 3495 + static const char *sock_prot_memory_pressure(struct proto *proto) 3501 3496 { 3502 3497 return proto->memory_pressure != NULL ? 3503 3498 proto_memory_pressure(proto) ? "yes" : "no" : "NI";
+1 -1
net/dccp/ipv4.c
··· 871 871 872 872 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) 873 873 goto discard_and_relse; 874 - nf_reset(skb); 874 + nf_reset_ct(skb); 875 875 876 876 return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4, refcounted); 877 877
+11 -1
net/dsa/tag_sja1105.c
··· 156 156 /* Step 1: A timestampable frame was received. 157 157 * Buffer it until we get its meta frame. 158 158 */ 159 - if (is_link_local && sp->data->hwts_rx_en) { 159 + if (is_link_local) { 160 + if (!test_bit(SJA1105_HWTS_RX_EN, &sp->data->state)) 161 + /* Do normal processing. */ 162 + return skb; 163 + 160 164 spin_lock(&sp->data->meta_lock); 161 165 /* Was this a link-local frame instead of the meta 162 166 * that we were expecting? ··· 190 186 */ 191 187 } else if (is_meta) { 192 188 struct sk_buff *stampable_skb; 189 + 190 + /* Drop the meta frame if we're not in the right state 191 + * to process it. 192 + */ 193 + if (!test_bit(SJA1105_HWTS_RX_EN, &sp->data->state)) 194 + return NULL; 193 195 194 196 spin_lock(&sp->data->meta_lock); 195 197
+1
net/ipv4/ip_gre.c
··· 1446 1446 struct ip_tunnel *t = netdev_priv(dev); 1447 1447 1448 1448 ether_setup(dev); 1449 + dev->max_mtu = 0; 1449 1450 dev->netdev_ops = &erspan_netdev_ops; 1450 1451 dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1451 1452 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
+1 -1
net/ipv4/ip_input.c
··· 199 199 kfree_skb(skb); 200 200 return; 201 201 } 202 - nf_reset(skb); 202 + nf_reset_ct(skb); 203 203 } 204 204 ret = INDIRECT_CALL_2(ipprot->handler, tcp_v4_rcv, udp_rcv, 205 205 skb);
+2 -2
net/ipv4/ipmr.c
··· 1794 1794 ip_send_check(iph); 1795 1795 1796 1796 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 1797 - nf_reset(skb); 1797 + nf_reset_ct(skb); 1798 1798 } 1799 1799 1800 1800 static inline int ipmr_forward_finish(struct net *net, struct sock *sk, ··· 2140 2140 2141 2141 mroute_sk = rcu_dereference(mrt->mroute_sk); 2142 2142 if (mroute_sk) { 2143 - nf_reset(skb); 2143 + nf_reset_ct(skb); 2144 2144 raw_rcv(mroute_sk, skb); 2145 2145 return 0; 2146 2146 }
+1 -1
net/ipv4/netfilter/nf_dup_ipv4.c
··· 65 65 66 66 #if IS_ENABLED(CONFIG_NF_CONNTRACK) 67 67 /* Avoid counting cloned packets towards the original connection. */ 68 - nf_reset(skb); 68 + nf_reset_ct(skb); 69 69 nf_ct_set(skb, NULL, IP_CT_UNTRACKED); 70 70 #endif 71 71 /*
+1 -1
net/ipv4/raw.c
··· 332 332 kfree_skb(skb); 333 333 return NET_RX_DROP; 334 334 } 335 - nf_reset(skb); 335 + nf_reset_ct(skb); 336 336 337 337 skb_push(skb, skb->data - skb_network_header(skb)); 338 338
+2 -3
net/ipv4/route.c
··· 916 916 if (peer->rate_tokens == 0 || 917 917 time_after(jiffies, 918 918 (peer->rate_last + 919 - (ip_rt_redirect_load << peer->rate_tokens)))) { 919 + (ip_rt_redirect_load << peer->n_redirects)))) { 920 920 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr); 921 921 922 922 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw); 923 923 peer->rate_last = jiffies; 924 - ++peer->rate_tokens; 925 924 ++peer->n_redirects; 926 925 #ifdef CONFIG_IP_ROUTE_VERBOSE 927 926 if (log_martians && 928 - peer->rate_tokens == ip_rt_redirect_number) 927 + peer->n_redirects == ip_rt_redirect_number) 929 928 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n", 930 929 &ip_hdr(skb)->saddr, inet_iif(skb), 931 930 &ip_hdr(skb)->daddr, &gw);
+2 -4
net/ipv4/tcp.c
··· 1798 1798 } 1799 1799 if (skb_frag_size(frags) != PAGE_SIZE || skb_frag_off(frags)) { 1800 1800 int remaining = zc->recv_skip_hint; 1801 - int size = skb_frag_size(frags); 1802 1801 1803 - while (remaining && (size != PAGE_SIZE || 1802 + while (remaining && (skb_frag_size(frags) != PAGE_SIZE || 1804 1803 skb_frag_off(frags))) { 1805 - remaining -= size; 1804 + remaining -= skb_frag_size(frags); 1806 1805 frags++; 1807 - size = skb_frag_size(frags); 1808 1806 } 1809 1807 zc->recv_skip_hint -= remaining; 1810 1808 break;
+1 -1
net/ipv4/tcp_ipv4.c
··· 1916 1916 if (tcp_v4_inbound_md5_hash(sk, skb)) 1917 1917 goto discard_and_relse; 1918 1918 1919 - nf_reset(skb); 1919 + nf_reset_ct(skb); 1920 1920 1921 1921 if (tcp_filter(sk, skb)) 1922 1922 goto discard_and_relse;
+7 -2
net/ipv4/tcp_timer.c
··· 198 198 return false; 199 199 200 200 start_ts = tcp_sk(sk)->retrans_stamp; 201 - if (likely(timeout == 0)) 202 - timeout = tcp_model_timeout(sk, boundary, TCP_RTO_MIN); 201 + if (likely(timeout == 0)) { 202 + unsigned int rto_base = TCP_RTO_MIN; 203 + 204 + if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) 205 + rto_base = tcp_timeout_init(sk); 206 + timeout = tcp_model_timeout(sk, boundary, rto_base); 207 + } 203 208 204 209 return (s32)(tcp_time_stamp(tcp_sk(sk)) - start_ts - timeout) >= 0; 205 210 }
+9 -6
net/ipv4/udp.c
··· 821 821 int is_udplite = IS_UDPLITE(sk); 822 822 int offset = skb_transport_offset(skb); 823 823 int len = skb->len - offset; 824 + int datalen = len - sizeof(*uh); 824 825 __wsum csum = 0; 825 826 826 827 /* ··· 855 854 return -EIO; 856 855 } 857 856 858 - skb_shinfo(skb)->gso_size = cork->gso_size; 859 - skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4; 860 - skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(len - sizeof(uh), 861 - cork->gso_size); 857 + if (datalen > cork->gso_size) { 858 + skb_shinfo(skb)->gso_size = cork->gso_size; 859 + skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4; 860 + skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen, 861 + cork->gso_size); 862 + } 862 863 goto csum_partial; 863 864 } 864 865 ··· 1972 1969 */ 1973 1970 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) 1974 1971 goto drop; 1975 - nf_reset(skb); 1972 + nf_reset_ct(skb); 1976 1973 1977 1974 if (static_branch_unlikely(&udp_encap_needed_key) && up->encap_type) { 1978 1975 int (*encap_rcv)(struct sock *sk, struct sk_buff *skb); ··· 2301 2298 2302 2299 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) 2303 2300 goto drop; 2304 - nf_reset(skb); 2301 + nf_reset_ct(skb); 2305 2302 2306 2303 /* No socket. Drop packet silently, if checksum is wrong */ 2307 2304 if (udp_lib_checksum_complete(skb))
+12 -5
net/ipv6/addrconf.c
··· 5964 5964 switch (event) { 5965 5965 case RTM_NEWADDR: 5966 5966 /* 5967 - * If the address was optimistic 5968 - * we inserted the route at the start of 5969 - * our DAD process, so we don't need 5970 - * to do it again 5967 + * If the address was optimistic we inserted the route at the 5968 + * start of our DAD process, so we don't need to do it again. 5969 + * If the device was taken down in the middle of the DAD 5970 + * cycle there is a race where we could get here without a 5971 + * host route, so nothing to insert. That will be fixed when 5972 + * the device is brought up. 5971 5973 */ 5972 - if (!rcu_access_pointer(ifp->rt->fib6_node)) 5974 + if (ifp->rt && !rcu_access_pointer(ifp->rt->fib6_node)) { 5973 5975 ip6_ins_rt(net, ifp->rt); 5976 + } else if (!ifp->rt && (ifp->idev->dev->flags & IFF_UP)) { 5977 + pr_warn("BUG: Address %pI6c on device %s is missing its host route.\n", 5978 + &ifp->addr, ifp->idev->dev->name); 5979 + } 5980 + 5974 5981 if (ifp->idev->cnf.forwarding) 5975 5982 addrconf_join_anycast(ifp); 5976 5983 if (!ipv6_addr_any(&ifp->peer_addr))
+11 -1
net/ipv6/ip6_input.c
··· 223 223 if (ipv6_addr_is_multicast(&hdr->saddr)) 224 224 goto err; 225 225 226 + /* While RFC4291 is not explicit about v4mapped addresses 227 + * in IPv6 headers, it seems clear linux dual-stack 228 + * model can not deal properly with these. 229 + * Security models could be fooled by ::ffff:127.0.0.1 for example. 230 + * 231 + * https://tools.ietf.org/html/draft-itojun-v6ops-v4mapped-harmful-02 232 + */ 233 + if (ipv6_addr_v4mapped(&hdr->saddr)) 234 + goto err; 235 + 226 236 skb->transport_header = skb->network_header + sizeof(*hdr); 227 237 IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr); 228 238 ··· 381 371 /* Free reference early: we don't need it any more, 382 372 and it may hold ip_conntrack module loaded 383 373 indefinitely. */ 384 - nf_reset(skb); 374 + nf_reset_ct(skb); 385 375 386 376 skb_postpull_rcsum(skb, skb_network_header(skb), 387 377 skb_network_header_len(skb));
+1 -1
net/ipv6/netfilter/nf_dup_ipv6.c
··· 54 54 return; 55 55 56 56 #if IS_ENABLED(CONFIG_NF_CONNTRACK) 57 - nf_reset(skb); 57 + nf_reset_ct(skb); 58 58 nf_ct_set(skb, NULL, IP_CT_UNTRACKED); 59 59 #endif 60 60 if (hooknum == NF_INET_PRE_ROUTING ||
+1 -1
net/ipv6/raw.c
··· 215 215 216 216 /* Not releasing hash table! */ 217 217 if (clone) { 218 - nf_reset(clone); 218 + nf_reset_ct(clone); 219 219 rawv6_rcv(sk, clone); 220 220 } 221 221 }
+7 -2
net/ipv6/udp.c
··· 1109 1109 __wsum csum = 0; 1110 1110 int offset = skb_transport_offset(skb); 1111 1111 int len = skb->len - offset; 1112 + int datalen = len - sizeof(*uh); 1112 1113 1113 1114 /* 1114 1115 * Create a UDP header ··· 1142 1141 return -EIO; 1143 1142 } 1144 1143 1145 - skb_shinfo(skb)->gso_size = cork->gso_size; 1146 - skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4; 1144 + if (datalen > cork->gso_size) { 1145 + skb_shinfo(skb)->gso_size = cork->gso_size; 1146 + skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4; 1147 + skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen, 1148 + cork->gso_size); 1149 + } 1147 1150 goto csum_partial; 1148 1151 } 1149 1152
+1 -1
net/l2tp/l2tp_core.c
··· 1078 1078 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 1079 1079 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED | 1080 1080 IPSKB_REROUTED); 1081 - nf_reset(skb); 1081 + nf_reset_ct(skb); 1082 1082 1083 1083 bh_lock_sock(sk); 1084 1084 if (sock_owned_by_user(sk)) {
+1 -1
net/l2tp/l2tp_eth.c
··· 151 151 skb->ip_summed = CHECKSUM_NONE; 152 152 153 153 skb_dst_drop(skb); 154 - nf_reset(skb); 154 + nf_reset_ct(skb); 155 155 156 156 rcu_read_lock(); 157 157 dev = rcu_dereference(spriv->dev);
+1 -1
net/l2tp/l2tp_ip.c
··· 193 193 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) 194 194 goto discard_put; 195 195 196 - nf_reset(skb); 196 + nf_reset_ct(skb); 197 197 198 198 return sk_receive_skb(sk, skb, 1); 199 199
+1 -1
net/l2tp/l2tp_ip6.c
··· 206 206 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) 207 207 goto discard_put; 208 208 209 - nf_reset(skb); 209 + nf_reset_ct(skb); 210 210 211 211 return sk_receive_skb(sk, skb, 1); 212 212
+9 -2
net/mac80211/debugfs_netdev.c
··· 487 487 const struct ieee80211_sub_if_data *sdata, char *buf, int buflen) 488 488 { 489 489 struct ieee80211_local *local = sdata->local; 490 - struct txq_info *txqi = to_txq_info(sdata->vif.txq); 490 + struct txq_info *txqi; 491 491 int len; 492 + 493 + if (!sdata->vif.txq) 494 + return 0; 495 + 496 + txqi = to_txq_info(sdata->vif.txq); 492 497 493 498 spin_lock_bh(&local->fq.lock); 494 499 rcu_read_lock(); ··· 663 658 DEBUGFS_ADD(rc_rateidx_vht_mcs_mask_5ghz); 664 659 DEBUGFS_ADD(hw_queues); 665 660 666 - if (sdata->local->ops->wake_tx_queue) 661 + if (sdata->local->ops->wake_tx_queue && 662 + sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE && 663 + sdata->vif.type != NL80211_IFTYPE_NAN) 667 664 DEBUGFS_ADD(aqm); 668 665 } 669 666
+8 -5
net/mac80211/util.c
··· 247 247 struct sta_info *sta; 248 248 int i; 249 249 250 - spin_lock_bh(&fq->lock); 250 + local_bh_disable(); 251 + spin_lock(&fq->lock); 251 252 252 253 if (sdata->vif.type == NL80211_IFTYPE_AP) 253 254 ps = &sdata->bss->ps; ··· 274 273 &txqi->flags)) 275 274 continue; 276 275 277 - spin_unlock_bh(&fq->lock); 276 + spin_unlock(&fq->lock); 278 277 drv_wake_tx_queue(local, txqi); 279 - spin_lock_bh(&fq->lock); 278 + spin_lock(&fq->lock); 280 279 } 281 280 } 282 281 ··· 289 288 (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac) 290 289 goto out; 291 290 292 - spin_unlock_bh(&fq->lock); 291 + spin_unlock(&fq->lock); 293 292 294 293 drv_wake_tx_queue(local, txqi); 294 + local_bh_enable(); 295 295 return; 296 296 out: 297 - spin_unlock_bh(&fq->lock); 297 + spin_unlock(&fq->lock); 298 + local_bh_enable(); 298 299 } 299 300 300 301 static void
+1 -1
net/netfilter/ipvs/ip_vs_xmit.c
··· 613 613 if (unlikely(cp->flags & IP_VS_CONN_F_NFCT)) 614 614 ret = ip_vs_confirm_conntrack(skb); 615 615 if (ret == NF_ACCEPT) { 616 - nf_reset(skb); 616 + nf_reset_ct(skb); 617 617 skb_forward_csum(skb); 618 618 } 619 619 return ret;
+6 -1
net/netfilter/nft_connlimit.c
··· 218 218 static bool nft_connlimit_gc(struct net *net, const struct nft_expr *expr) 219 219 { 220 220 struct nft_connlimit *priv = nft_expr_priv(expr); 221 + bool ret; 221 222 222 - return nf_conncount_gc_list(net, &priv->list); 223 + local_bh_disable(); 224 + ret = nf_conncount_gc_list(net, &priv->list); 225 + local_bh_enable(); 226 + 227 + return ret; 223 228 } 224 229 225 230 static struct nft_expr_type nft_connlimit_type;
+6 -1
net/nfc/llcp_sock.c
··· 107 107 llcp_sock->service_name = kmemdup(llcp_addr.service_name, 108 108 llcp_sock->service_name_len, 109 109 GFP_KERNEL); 110 - 110 + if (!llcp_sock->service_name) { 111 + ret = -ENOMEM; 112 + goto put_dev; 113 + } 111 114 llcp_sock->ssap = nfc_llcp_get_sdp_ssap(local, llcp_sock); 112 115 if (llcp_sock->ssap == LLCP_SAP_MAX) { 116 + kfree(llcp_sock->service_name); 117 + llcp_sock->service_name = NULL; 113 118 ret = -EADDRINUSE; 114 119 goto put_dev; 115 120 }
+1 -1
net/openvswitch/vport-internal_dev.c
··· 237 237 } 238 238 239 239 skb_dst_drop(skb); 240 - nf_reset(skb); 240 + nf_reset_ct(skb); 241 241 secpath_reset(skb); 242 242 243 243 skb->pkt_type = PACKET_HOST;
+2 -2
net/packet/af_packet.c
··· 1821 1821 skb_dst_drop(skb); 1822 1822 1823 1823 /* drop conntrack reference */ 1824 - nf_reset(skb); 1824 + nf_reset_ct(skb); 1825 1825 1826 1826 spkt = &PACKET_SKB_CB(skb)->sa.pkt; 1827 1827 ··· 2121 2121 skb_dst_drop(skb); 2122 2122 2123 2123 /* drop conntrack reference */ 2124 - nf_reset(skb); 2124 + nf_reset_ct(skb); 2125 2125 2126 2126 spin_lock(&sk->sk_receive_queue.lock); 2127 2127 po->stats.stats1.tp_packets++;
+3 -3
net/rds/ib.c
··· 143 143 refcount_set(&rds_ibdev->refcount, 1); 144 144 INIT_WORK(&rds_ibdev->free_work, rds_ib_dev_free); 145 145 146 + INIT_LIST_HEAD(&rds_ibdev->ipaddr_list); 147 + INIT_LIST_HEAD(&rds_ibdev->conn_list); 148 + 146 149 rds_ibdev->max_wrs = device->attrs.max_qp_wr; 147 150 rds_ibdev->max_sge = min(device->attrs.max_send_sge, RDS_IB_MAX_SGE); 148 151 ··· 205 202 pr_info("RDS/IB: %s: %s supported and preferred\n", 206 203 device->name, 207 204 rds_ibdev->use_fastreg ? "FRMR" : "FMR"); 208 - 209 - INIT_LIST_HEAD(&rds_ibdev->ipaddr_list); 210 - INIT_LIST_HEAD(&rds_ibdev->conn_list); 211 205 212 206 down_write(&rds_ib_devices_lock); 213 207 list_add_tail_rcu(&rds_ibdev->list, &rds_ib_devices);
+29 -14
net/sched/sch_cbq.c
··· 1127 1127 [TCA_CBQ_POLICE] = { .len = sizeof(struct tc_cbq_police) }, 1128 1128 }; 1129 1129 1130 + static int cbq_opt_parse(struct nlattr *tb[TCA_CBQ_MAX + 1], 1131 + struct nlattr *opt, 1132 + struct netlink_ext_ack *extack) 1133 + { 1134 + int err; 1135 + 1136 + if (!opt) { 1137 + NL_SET_ERR_MSG(extack, "CBQ options are required for this operation"); 1138 + return -EINVAL; 1139 + } 1140 + 1141 + err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt, 1142 + cbq_policy, extack); 1143 + if (err < 0) 1144 + return err; 1145 + 1146 + if (tb[TCA_CBQ_WRROPT]) { 1147 + const struct tc_cbq_wrropt *wrr = nla_data(tb[TCA_CBQ_WRROPT]); 1148 + 1149 + if (wrr->priority > TC_CBQ_MAXPRIO) { 1150 + NL_SET_ERR_MSG(extack, "priority is bigger than TC_CBQ_MAXPRIO"); 1151 + err = -EINVAL; 1152 + } 1153 + } 1154 + return err; 1155 + } 1156 + 1130 1157 static int cbq_init(struct Qdisc *sch, struct nlattr *opt, 1131 1158 struct netlink_ext_ack *extack) 1132 1159 { ··· 1166 1139 hrtimer_init(&q->delay_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED); 1167 1140 q->delay_timer.function = cbq_undelay; 1168 1141 1169 - if (!opt) { 1170 - NL_SET_ERR_MSG(extack, "CBQ options are required for this operation"); 1171 - return -EINVAL; 1172 - } 1173 - 1174 - err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt, cbq_policy, 1175 - extack); 1142 + err = cbq_opt_parse(tb, opt, extack); 1176 1143 if (err < 0) 1177 1144 return err; 1178 1145 ··· 1485 1464 struct cbq_class *parent; 1486 1465 struct qdisc_rate_table *rtab = NULL; 1487 1466 1488 - if (!opt) { 1489 - NL_SET_ERR_MSG(extack, "Mandatory qdisc options missing"); 1490 - return -EINVAL; 1491 - } 1492 - 1493 - err = nla_parse_nested_deprecated(tb, TCA_CBQ_MAX, opt, cbq_policy, 1494 - extack); 1467 + err = cbq_opt_parse(tb, opt, extack); 1495 1468 if (err < 0) 1496 1469 return err; 1497 1470
+1 -1
net/sched/sch_cbs.c
··· 306 306 if (err < 0) 307 307 goto skip; 308 308 309 - if (ecmd.base.speed != SPEED_UNKNOWN) 309 + if (ecmd.base.speed && ecmd.base.speed != SPEED_UNKNOWN) 310 310 speed = ecmd.base.speed; 311 311 312 312 skip:
+2
net/sched/sch_dsmark.c
··· 361 361 goto errout; 362 362 363 363 err = -EINVAL; 364 + if (!tb[TCA_DSMARK_INDICES]) 365 + goto errout; 364 366 indices = nla_get_u16(tb[TCA_DSMARK_INDICES]); 365 367 366 368 if (hweight32(indices) != 1)
+2 -3
net/sched/sch_taprio.c
··· 1044 1044 if (err < 0) 1045 1045 goto skip; 1046 1046 1047 - if (ecmd.base.speed != SPEED_UNKNOWN) 1047 + if (ecmd.base.speed && ecmd.base.speed != SPEED_UNKNOWN) 1048 1048 speed = ecmd.base.speed; 1049 1049 1050 1050 skip: 1051 - picos_per_byte = div64_s64(NSEC_PER_SEC * 1000LL * 8, 1052 - speed * 1000 * 1000); 1051 + picos_per_byte = (USEC_PER_SEC * 8) / speed; 1053 1052 1054 1053 atomic64_set(&q->picos_per_byte, picos_per_byte); 1055 1054 netdev_dbg(dev, "taprio: set %s's picos_per_byte to: %lld, linkspeed: %d\n",
+1 -1
net/sctp/input.c
··· 201 201 202 202 if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family)) 203 203 goto discard_release; 204 - nf_reset(skb); 204 + nf_reset_ct(skb); 205 205 206 206 if (sk_filter(sk, skb)) 207 207 goto discard_release;
+18 -11
net/tipc/link.c
··· 160 160 struct { 161 161 u16 len; 162 162 u16 limit; 163 + struct sk_buff *target_bskb; 163 164 } backlog[5]; 164 165 u16 snd_nxt; 165 166 u16 window; ··· 881 880 void tipc_link_reset(struct tipc_link *l) 882 881 { 883 882 struct sk_buff_head list; 883 + u32 imp; 884 884 885 885 __skb_queue_head_init(&list); 886 886 ··· 903 901 __skb_queue_purge(&l->deferdq); 904 902 __skb_queue_purge(&l->backlogq); 905 903 __skb_queue_purge(&l->failover_deferdq); 906 - l->backlog[TIPC_LOW_IMPORTANCE].len = 0; 907 - l->backlog[TIPC_MEDIUM_IMPORTANCE].len = 0; 908 - l->backlog[TIPC_HIGH_IMPORTANCE].len = 0; 909 - l->backlog[TIPC_CRITICAL_IMPORTANCE].len = 0; 910 - l->backlog[TIPC_SYSTEM_IMPORTANCE].len = 0; 904 + for (imp = 0; imp <= TIPC_SYSTEM_IMPORTANCE; imp++) { 905 + l->backlog[imp].len = 0; 906 + l->backlog[imp].target_bskb = NULL; 907 + } 911 908 kfree_skb(l->reasm_buf); 912 909 kfree_skb(l->reasm_tnlmsg); 913 910 kfree_skb(l->failover_reasm_skb); ··· 948 947 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1; 949 948 struct sk_buff_head *transmq = &l->transmq; 950 949 struct sk_buff_head *backlogq = &l->backlogq; 951 - struct sk_buff *skb, *_skb, *bskb; 950 + struct sk_buff *skb, *_skb, **tskb; 952 951 int pkt_cnt = skb_queue_len(list); 953 952 int rc = 0; 954 953 ··· 1000 999 seqno++; 1001 1000 continue; 1002 1001 } 1003 - if (tipc_msg_bundle(skb_peek_tail(backlogq), hdr, mtu)) { 1002 + tskb = &l->backlog[imp].target_bskb; 1003 + if (tipc_msg_bundle(*tskb, hdr, mtu)) { 1004 1004 kfree_skb(__skb_dequeue(list)); 1005 1005 l->stats.sent_bundled++; 1006 1006 continue; 1007 1007 } 1008 - if (tipc_msg_make_bundle(&bskb, hdr, mtu, l->addr)) { 1008 + if (tipc_msg_make_bundle(tskb, hdr, mtu, l->addr)) { 1009 1009 kfree_skb(__skb_dequeue(list)); 1010 - __skb_queue_tail(backlogq, bskb); 1011 - l->backlog[msg_importance(buf_msg(bskb))].len++; 1010 + __skb_queue_tail(backlogq, *tskb); 1011 + l->backlog[imp].len++; 1012 1012 l->stats.sent_bundled++; 1013 1013 l->stats.sent_bundles++; 1014 1014 continue; 1015 1015 } 1016 + l->backlog[imp].target_bskb = NULL; 1016 1017 l->backlog[imp].len += skb_queue_len(list); 1017 1018 skb_queue_splice_tail_init(list, backlogq); 1018 1019 } ··· 1030 1027 u16 seqno = l->snd_nxt; 1031 1028 u16 ack = l->rcv_nxt - 1; 1032 1029 u16 bc_ack = l->bc_rcvlink->rcv_nxt - 1; 1030 + u32 imp; 1033 1031 1034 1032 while (skb_queue_len(&l->transmq) < l->window) { 1035 1033 skb = skb_peek(&l->backlogq); ··· 1041 1037 break; 1042 1038 __skb_dequeue(&l->backlogq); 1043 1039 hdr = buf_msg(skb); 1044 - l->backlog[msg_importance(hdr)].len--; 1040 + imp = msg_importance(hdr); 1041 + l->backlog[imp].len--; 1042 + if (unlikely(skb == l->backlog[imp].target_bskb)) 1043 + l->backlog[imp].target_bskb = NULL; 1045 1044 __skb_queue_tail(&l->transmq, skb); 1046 1045 /* next retransmit attempt */ 1047 1046 if (link_is_bc_sndlink(l))
+1 -4
net/tipc/msg.c
··· 543 543 bmsg = buf_msg(_skb); 544 544 tipc_msg_init(msg_prevnode(msg), bmsg, MSG_BUNDLER, 0, 545 545 INT_H_SIZE, dnode); 546 - if (msg_isdata(msg)) 547 - msg_set_importance(bmsg, TIPC_CRITICAL_IMPORTANCE); 548 - else 549 - msg_set_importance(bmsg, TIPC_SYSTEM_IMPORTANCE); 546 + msg_set_importance(bmsg, msg_importance(msg)); 550 547 msg_set_seqno(bmsg, msg_seqno(msg)); 551 548 msg_set_ack(bmsg, msg_ack(msg)); 552 549 msg_set_bcast_ack(bmsg, msg_bcast_ack(msg));
+12 -4
net/vmw_vsock/af_vsock.c
··· 638 638 } 639 639 EXPORT_SYMBOL_GPL(__vsock_create); 640 640 641 - static void __vsock_release(struct sock *sk) 641 + static void __vsock_release(struct sock *sk, int level) 642 642 { 643 643 if (sk) { 644 644 struct sk_buff *skb; ··· 648 648 vsk = vsock_sk(sk); 649 649 pending = NULL; /* Compiler warning. */ 650 650 651 + /* The release call is supposed to use lock_sock_nested() 652 + * rather than lock_sock(), if a sock lock should be acquired. 653 + */ 651 654 transport->release(vsk); 652 655 653 - lock_sock(sk); 656 + /* When "level" is SINGLE_DEPTH_NESTING, use the nested 657 + * version to avoid the warning "possible recursive locking 658 + * detected". When "level" is 0, lock_sock_nested(sk, level) 659 + * is the same as lock_sock(sk). 660 + */ 661 + lock_sock_nested(sk, level); 654 662 sock_orphan(sk); 655 663 sk->sk_shutdown = SHUTDOWN_MASK; 656 664 ··· 667 659 668 660 /* Clean up any sockets that never were accepted. */ 669 661 while ((pending = vsock_dequeue_accept(sk)) != NULL) { 670 - __vsock_release(pending); 662 + __vsock_release(pending, SINGLE_DEPTH_NESTING); 671 663 sock_put(pending); 672 664 } 673 665 ··· 716 708 717 709 static int vsock_release(struct socket *sock) 718 710 { 719 - __vsock_release(sock->sk); 711 + __vsock_release(sock->sk, 0); 720 712 sock->sk = NULL; 721 713 sock->state = SS_FREE; 722 714
+1 -1
net/vmw_vsock/hyperv_transport.c
··· 559 559 struct sock *sk = sk_vsock(vsk); 560 560 bool remove_sock; 561 561 562 - lock_sock(sk); 562 + lock_sock_nested(sk, SINGLE_DEPTH_NESTING); 563 563 remove_sock = hvs_close_lock_held(vsk); 564 564 release_sock(sk); 565 565 if (remove_sock)
+1 -1
net/vmw_vsock/virtio_transport_common.c
··· 820 820 struct sock *sk = &vsk->sk; 821 821 bool remove_sock = true; 822 822 823 - lock_sock(sk); 823 + lock_sock_nested(sk, SINGLE_DEPTH_NESTING); 824 824 if (sk->sk_type == SOCK_STREAM) 825 825 remove_sock = virtio_transport_close(vsk); 826 826
+41 -3
net/wireless/nl80211.c
··· 201 201 return __cfg80211_rdev_from_attrs(netns, info->attrs); 202 202 } 203 203 204 + static int validate_beacon_head(const struct nlattr *attr, 205 + struct netlink_ext_ack *extack) 206 + { 207 + const u8 *data = nla_data(attr); 208 + unsigned int len = nla_len(attr); 209 + const struct element *elem; 210 + const struct ieee80211_mgmt *mgmt = (void *)data; 211 + unsigned int fixedlen = offsetof(struct ieee80211_mgmt, 212 + u.beacon.variable); 213 + 214 + if (len < fixedlen) 215 + goto err; 216 + 217 + if (ieee80211_hdrlen(mgmt->frame_control) != 218 + offsetof(struct ieee80211_mgmt, u.beacon)) 219 + goto err; 220 + 221 + data += fixedlen; 222 + len -= fixedlen; 223 + 224 + for_each_element(elem, data, len) { 225 + /* nothing */ 226 + } 227 + 228 + if (for_each_element_completed(elem, data, len)) 229 + return 0; 230 + 231 + err: 232 + NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head"); 233 + return -EINVAL; 234 + } 235 + 204 236 static int validate_ie_attr(const struct nlattr *attr, 205 237 struct netlink_ext_ack *extack) 206 238 { ··· 370 338 371 339 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 }, 372 340 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 }, 373 - [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY, 374 - .len = IEEE80211_MAX_DATA_LEN }, 341 + [NL80211_ATTR_BEACON_HEAD] = 342 + NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head, 343 + IEEE80211_MAX_DATA_LEN), 375 344 [NL80211_ATTR_BEACON_TAIL] = 376 345 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr, 377 346 IEEE80211_MAX_DATA_LEN), ··· 2669 2636 2670 2637 control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]); 2671 2638 2639 + memset(chandef, 0, sizeof(*chandef)); 2640 + 2672 2641 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq); 2673 2642 chandef->width = NL80211_CHAN_WIDTH_20_NOHT; 2674 2643 chandef->center_freq1 = control_freq; ··· 3211 3176 3212 3177 if (rdev->ops->get_channel) { 3213 3178 int ret; 3214 - struct cfg80211_chan_def chandef; 3179 + struct cfg80211_chan_def chandef = {}; 3215 3180 3216 3181 ret = rdev_get_channel(rdev, wdev, &chandef); 3217 3182 if (ret == 0) { ··· 6303 6268 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 6304 6269 6305 6270 if (!rdev->ops->del_mpath) 6271 + return -EOPNOTSUPP; 6272 + 6273 + if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 6306 6274 return -EOPNOTSUPP; 6307 6275 6308 6276 return rdev_del_mpath(rdev, dev, dst);
+1 -1
net/wireless/reg.c
··· 2108 2108 2109 2109 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev) 2110 2110 { 2111 - struct cfg80211_chan_def chandef; 2111 + struct cfg80211_chan_def chandef = {}; 2112 2112 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 2113 2113 enum nl80211_iftype iftype; 2114 2114
+6 -1
net/wireless/scan.c
··· 1723 1723 return; 1724 1724 new_ie_len -= trans_ssid[1]; 1725 1725 mbssid = cfg80211_find_ie(WLAN_EID_MULTIPLE_BSSID, ie, ielen); 1726 - if (!mbssid) 1726 + /* 1727 + * It's not valid to have the MBSSID element before SSID 1728 + * ignore if that happens - the code below assumes it is 1729 + * after (while copying things inbetween). 1730 + */ 1731 + if (!mbssid || mbssid < trans_ssid) 1727 1732 return; 1728 1733 new_ie_len -= mbssid[1]; 1729 1734 rcu_read_lock();
+1 -1
net/wireless/wext-compat.c
··· 798 798 { 799 799 struct wireless_dev *wdev = dev->ieee80211_ptr; 800 800 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 801 - struct cfg80211_chan_def chandef; 801 + struct cfg80211_chan_def chandef = {}; 802 802 int ret; 803 803 804 804 switch (wdev->iftype) {
+1 -1
net/xfrm/xfrm_input.c
··· 706 706 if (err) 707 707 goto drop; 708 708 709 - nf_reset(skb); 709 + nf_reset_ct(skb); 710 710 711 711 if (decaps) { 712 712 sp = skb_sec_path(skb);
+1 -1
net/xfrm/xfrm_interface.c
··· 185 185 skb->skb_iif = 0; 186 186 skb->ignore_df = 0; 187 187 skb_dst_drop(skb); 188 - nf_reset(skb); 188 + nf_reset_ct(skb); 189 189 nf_reset_trace(skb); 190 190 191 191 if (!xnet)
+1 -1
net/xfrm/xfrm_output.c
··· 502 502 struct net *net = xs_net(skb_dst(skb)->xfrm); 503 503 504 504 while (likely((err = xfrm_output_one(skb, err)) == 0)) { 505 - nf_reset(skb); 505 + nf_reset_ct(skb); 506 506 507 507 err = skb_dst(skb)->ops->local_out(net, skb->sk, skb); 508 508 if (unlikely(err != 1))
+1 -1
net/xfrm/xfrm_policy.c
··· 2808 2808 continue; 2809 2809 } 2810 2810 2811 - nf_reset(skb); 2811 + nf_reset_ct(skb); 2812 2812 skb_dst_drop(skb); 2813 2813 skb_dst_set(skb, dst); 2814 2814
+1
tools/testing/selftests/net/.gitignore
··· 21 21 ipv6_flowlabel_mgr 22 22 so_txtime 23 23 tcp_fastopen_backup_key 24 + nettest
+4 -12
tools/testing/selftests/net/udpgso.c
··· 89 89 .tfail = true, 90 90 }, 91 91 { 92 - /* send a single MSS: will fail with GSO, because the segment 93 - * logic in udp4_ufo_fragment demands a gso skb to be > MTU 94 - */ 92 + /* send a single MSS: will fall back to no GSO */ 95 93 .tlen = CONST_MSS_V4, 96 94 .gso_len = CONST_MSS_V4, 97 - .tfail = true, 98 95 .r_num_mss = 1, 99 96 }, 100 97 { ··· 136 139 .tfail = true, 137 140 }, 138 141 { 139 - /* send a single 1B MSS: will fail, see single MSS above */ 142 + /* send a single 1B MSS: will fall back to no GSO */ 140 143 .tlen = 1, 141 144 .gso_len = 1, 142 - .tfail = true, 143 145 .r_num_mss = 1, 144 146 }, 145 147 { ··· 192 196 .tfail = true, 193 197 }, 194 198 { 195 - /* send a single MSS: will fail with GSO, because the segment 196 - * logic in udp4_ufo_fragment demands a gso skb to be > MTU 197 - */ 199 + /* send a single MSS: will fall back to no GSO */ 198 200 .tlen = CONST_MSS_V6, 199 201 .gso_len = CONST_MSS_V6, 200 - .tfail = true, 201 202 .r_num_mss = 1, 202 203 }, 203 204 { ··· 239 246 .tfail = true, 240 247 }, 241 248 { 242 - /* send a single 1B MSS: will fail, see single MSS above */ 249 + /* send a single 1B MSS: will fall back to no GSO */ 243 250 .tlen = 1, 244 251 .gso_len = 1, 245 - .tfail = true, 246 252 .r_num_mss = 1, 247 253 }, 248 254 {