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 memory leak in xfrm_state code, from Steffen Klassert.

2) Fix races between devlink reload operations and device
setup/cleanup, from Jiri Pirko.

3) Null deref in NFC code, from Stephan Gerhold.

4) Refcount fixes in SMC, from Ursula Braun.

5) Memory leak in slcan open error paths, from Jouni Hogander.

6) Fix ETS bandwidth validation in hns3, from Yonglong Liu.

7) Info leak on short USB request answers in ax88172a driver, from
Oliver Neukum.

8) Release mem region properly in ep93xx_eth, from Chuhong Yuan.

9) PTP config timestamp flags validation, from Richard Cochran.

10) Dangling pointers after SKB data realloc in seg6, from Andrea Mayer.

11) Missing free_netdev() in gemini driver, from Chuhong Yuan.

* git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (56 commits)
ipmr: Fix skb headroom in ipmr_get_route().
net: hns3: cleanup of stray struct hns3_link_mode_mapping
net/smc: fix fastopen for non-blocking connect()
rds: ib: update WR sizes when bringing up connection
net: gemini: add missed free_netdev
net: dsa: tag_8021q: Fix dsa_8021q_restore_pvid for an absent pvid
seg6: fix skb transport_header after decap_and_validate()
seg6: fix srh pointer in get_srh()
net: stmmac: Use the correct style for SPDX License Identifier
octeontx2-af: Use the correct style for SPDX License Identifier
ptp: Extend the test program to check the external time stamp flags.
mlx5: Reject requests to enable time stamping on both edges.
igb: Reject requests that fail to enable time stamping on both edges.
dp83640: Reject requests to enable time stamping on both edges.
mv88e6xxx: Reject requests to enable time stamping on both edges.
ptp: Introduce strict checking of external time stamp options.
renesas: reject unsupported external timestamp flags
mlx5: reject unsupported external timestamp flags
igb: reject unsupported external timestamp flags
dp83640: reject unsupported external timestamp flags
...

Linus Torvalds 8be636dd bec8b6e9

+482 -125
+1
drivers/net/can/slcan.c
··· 617 617 sl->tty = NULL; 618 618 tty->disc_data = NULL; 619 619 clear_bit(SLF_INUSE, &sl->flags); 620 + free_netdev(sl->dev); 620 621 621 622 err_exit: 622 623 rtnl_unlock();
+13
drivers/net/dsa/mv88e6xxx/ptp.c
··· 273 273 int pin; 274 274 int err; 275 275 276 + /* Reject requests with unsupported flags */ 277 + if (rq->extts.flags & ~(PTP_ENABLE_FEATURE | 278 + PTP_RISING_EDGE | 279 + PTP_FALLING_EDGE | 280 + PTP_STRICT_FLAGS)) 281 + return -EOPNOTSUPP; 282 + 283 + /* Reject requests to enable time stamping on both edges. */ 284 + if ((rq->extts.flags & PTP_STRICT_FLAGS) && 285 + (rq->extts.flags & PTP_ENABLE_FEATURE) && 286 + (rq->extts.flags & PTP_EXTTS_EDGES) == PTP_EXTTS_EDGES) 287 + return -EOPNOTSUPP; 288 + 276 289 pin = ptp_find_pin(chip->ptp_clock, PTP_PF_EXTTS, rq->extts.index); 277 290 278 291 if (pin < 0)
+4
drivers/net/ethernet/broadcom/tg3.c
··· 6280 6280 6281 6281 switch (rq->type) { 6282 6282 case PTP_CLK_REQ_PEROUT: 6283 + /* Reject requests with unsupported flags */ 6284 + if (rq->perout.flags) 6285 + return -EOPNOTSUPP; 6286 + 6283 6287 if (rq->perout.index != 0) 6284 6288 return -EINVAL; 6285 6289
+3 -2
drivers/net/ethernet/cirrus/ep93xx_eth.c
··· 763 763 { 764 764 struct net_device *dev; 765 765 struct ep93xx_priv *ep; 766 + struct resource *mem; 766 767 767 768 dev = platform_get_drvdata(pdev); 768 769 if (dev == NULL) ··· 779 778 iounmap(ep->base_addr); 780 779 781 780 if (ep->res != NULL) { 782 - release_resource(ep->res); 783 - kfree(ep->res); 781 + mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 782 + release_mem_region(mem->start, resource_size(mem)); 784 783 } 785 784 786 785 free_netdev(dev);
+1
drivers/net/ethernet/cortina/gemini.c
··· 2524 2524 struct gemini_ethernet_port *port = platform_get_drvdata(pdev); 2525 2525 2526 2526 gemini_port_remove(port); 2527 + free_netdev(port->netdev); 2527 2528 return 0; 2528 2529 } 2529 2530
+9 -1
drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c
··· 2232 2232 err_service_reg: 2233 2233 free_channel(priv, channel); 2234 2234 err_alloc_ch: 2235 - if (err == -EPROBE_DEFER) 2235 + if (err == -EPROBE_DEFER) { 2236 + for (i = 0; i < priv->num_channels; i++) { 2237 + channel = priv->channel[i]; 2238 + nctx = &channel->nctx; 2239 + dpaa2_io_service_deregister(channel->dpio, nctx, dev); 2240 + free_channel(priv, channel); 2241 + } 2242 + priv->num_channels = 0; 2236 2243 return err; 2244 + } 2237 2245 2238 2246 if (cpumask_empty(&priv->dpio_cpumask)) { 2239 2247 dev_err(dev, "No cpu with an affine DPIO/DPCON\n");
-5
drivers/net/ethernet/hisilicon/hns3/hns3_ethtool.c
··· 70 70 #define HNS3_NIC_LB_TEST_TX_CNT_ERR 2 71 71 #define HNS3_NIC_LB_TEST_RX_CNT_ERR 3 72 72 73 - struct hns3_link_mode_mapping { 74 - u32 hns3_link_mode; 75 - u32 ethtool_link_mode; 76 - }; 77 - 78 73 static int hns3_lp_setup(struct net_device *ndev, enum hnae3_loop loop, bool en) 79 74 { 80 75 struct hnae3_handle *h = hns3_get_handle(ndev);
+17 -2
drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.c
··· 124 124 if (ret) 125 125 return ret; 126 126 127 - for (i = 0; i < HNAE3_MAX_TC; i++) { 127 + for (i = 0; i < hdev->tc_max; i++) { 128 128 switch (ets->tc_tsa[i]) { 129 129 case IEEE_8021QAZ_TSA_STRICT: 130 130 if (hdev->tm_info.tc_info[i].tc_sch_mode != ··· 318 318 struct net_device *netdev = h->kinfo.netdev; 319 319 struct hclge_dev *hdev = vport->back; 320 320 u8 i, j, pfc_map, *prio_tc; 321 + int ret; 321 322 322 323 if (!(hdev->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 323 324 hdev->flag & HCLGE_FLAG_MQPRIO_ENABLE) ··· 348 347 349 348 hclge_tm_pfc_info_update(hdev); 350 349 351 - return hclge_pause_setup_hw(hdev, false); 350 + ret = hclge_pause_setup_hw(hdev, false); 351 + if (ret) 352 + return ret; 353 + 354 + ret = hclge_notify_client(hdev, HNAE3_DOWN_CLIENT); 355 + if (ret) 356 + return ret; 357 + 358 + ret = hclge_buffer_alloc(hdev); 359 + if (ret) { 360 + hclge_notify_client(hdev, HNAE3_UP_CLIENT); 361 + return ret; 362 + } 363 + 364 + return hclge_notify_client(hdev, HNAE3_UP_CLIENT); 352 365 } 353 366 354 367 /* DCBX configuration */
+14 -2
drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
··· 6263 6263 6264 6264 func_id = hclge_get_port_number(HOST_PORT, 0, vfid, 0); 6265 6265 req = (struct hclge_mac_vlan_switch_cmd *)desc.data; 6266 + 6267 + /* read current config parameter */ 6266 6268 hclge_cmd_setup_basic_desc(&desc, HCLGE_OPC_MAC_VLAN_SWITCH_PARAM, 6267 - false); 6269 + true); 6268 6270 req->roce_sel = HCLGE_MAC_VLAN_NIC_SEL; 6269 6271 req->func_id = cpu_to_le32(func_id); 6270 - req->switch_param = switch_param; 6272 + 6273 + ret = hclge_cmd_send(&hdev->hw, &desc, 1); 6274 + if (ret) { 6275 + dev_err(&hdev->pdev->dev, 6276 + "read mac vlan switch parameter fail, ret = %d\n", ret); 6277 + return ret; 6278 + } 6279 + 6280 + /* modify and write new config parameter */ 6281 + hclge_cmd_reuse_desc(&desc, false); 6282 + req->switch_param = (req->switch_param & param_mask) | switch_param; 6271 6283 req->param_mask = param_mask; 6272 6284 6273 6285 ret = hclge_cmd_send(&hdev->hw, &desc, 1);
+17
drivers/net/ethernet/intel/igb/igb_ptp.c
··· 521 521 522 522 switch (rq->type) { 523 523 case PTP_CLK_REQ_EXTTS: 524 + /* Reject requests with unsupported flags */ 525 + if (rq->extts.flags & ~(PTP_ENABLE_FEATURE | 526 + PTP_RISING_EDGE | 527 + PTP_FALLING_EDGE | 528 + PTP_STRICT_FLAGS)) 529 + return -EOPNOTSUPP; 530 + 531 + /* Reject requests failing to enable both edges. */ 532 + if ((rq->extts.flags & PTP_STRICT_FLAGS) && 533 + (rq->extts.flags & PTP_ENABLE_FEATURE) && 534 + (rq->extts.flags & PTP_EXTTS_EDGES) != PTP_EXTTS_EDGES) 535 + return -EOPNOTSUPP; 536 + 524 537 if (on) { 525 538 pin = ptp_find_pin(igb->ptp_clock, PTP_PF_EXTTS, 526 539 rq->extts.index); ··· 564 551 return 0; 565 552 566 553 case PTP_CLK_REQ_PEROUT: 554 + /* Reject requests with unsupported flags */ 555 + if (rq->perout.flags) 556 + return -EOPNOTSUPP; 557 + 567 558 if (on) { 568 559 pin = ptp_find_pin(igb->ptp_clock, PTP_PF_PEROUT, 569 560 rq->perout.index);
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/cgx.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 CGX driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 CGX driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/cgx_fw_if.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 CGX driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 CGX driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/common.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/mbox.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/npc.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/npc_profile.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/rvu.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/rvu_reg.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+2 -2
drivers/net/ethernet/marvell/octeontx2/af/rvu_struct.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 2 - * Marvell OcteonTx2 RVU Admin Function driver 1 + /* SPDX-License-Identifier: GPL-2.0 */ 2 + /* Marvell OcteonTx2 RVU Admin Function driver 3 3 * 4 4 * Copyright (C) 2018 Marvell International Ltd. 5 5 *
+3
drivers/net/ethernet/mellanox/mlx4/main.c
··· 4010 4010 goto err_params_unregister; 4011 4011 4012 4012 devlink_params_publish(devlink); 4013 + devlink_reload_enable(devlink); 4013 4014 pci_save_state(pdev); 4014 4015 return 0; 4015 4016 ··· 4121 4120 struct mlx4_priv *priv = mlx4_priv(dev); 4122 4121 struct devlink *devlink = priv_to_devlink(priv); 4123 4122 int active_vfs = 0; 4123 + 4124 + devlink_reload_disable(devlink); 4124 4125 4125 4126 if (mlx4_is_slave(dev)) 4126 4127 persist->interface_state |= MLX4_INTERFACE_STATE_NOWAIT;
+17
drivers/net/ethernet/mellanox/mlx5/core/lib/clock.c
··· 236 236 if (!MLX5_PPS_CAP(mdev)) 237 237 return -EOPNOTSUPP; 238 238 239 + /* Reject requests with unsupported flags */ 240 + if (rq->extts.flags & ~(PTP_ENABLE_FEATURE | 241 + PTP_RISING_EDGE | 242 + PTP_FALLING_EDGE | 243 + PTP_STRICT_FLAGS)) 244 + return -EOPNOTSUPP; 245 + 246 + /* Reject requests to enable time stamping on both edges. */ 247 + if ((rq->extts.flags & PTP_STRICT_FLAGS) && 248 + (rq->extts.flags & PTP_ENABLE_FEATURE) && 249 + (rq->extts.flags & PTP_EXTTS_EDGES) == PTP_EXTTS_EDGES) 250 + return -EOPNOTSUPP; 251 + 239 252 if (rq->extts.index >= clock->ptp_info.n_pins) 240 253 return -EINVAL; 241 254 ··· 301 288 s64 ns; 302 289 303 290 if (!MLX5_PPS_CAP(mdev)) 291 + return -EOPNOTSUPP; 292 + 293 + /* Reject requests with unsupported flags */ 294 + if (rq->perout.flags) 304 295 return -EOPNOTSUPP; 305 296 306 297 if (rq->perout.index >= clock->ptp_info.n_pins)
+5
drivers/net/ethernet/mellanox/mlxsw/core.c
··· 1189 1189 if (mlxsw_driver->params_register) 1190 1190 devlink_params_publish(devlink); 1191 1191 1192 + if (!reload) 1193 + devlink_reload_enable(devlink); 1194 + 1192 1195 return 0; 1193 1196 1194 1197 err_thermal_init: ··· 1252 1249 { 1253 1250 struct devlink *devlink = priv_to_devlink(mlxsw_core); 1254 1251 1252 + if (!reload) 1253 + devlink_reload_disable(devlink); 1255 1254 if (devlink_is_reload_failed(devlink)) { 1256 1255 if (!reload) 1257 1256 /* Only the parts that were not de-initialized in the
+4
drivers/net/ethernet/microchip/lan743x_ptp.c
··· 429 429 int pulse_width = 0; 430 430 int perout_bit = 0; 431 431 432 + /* Reject requests with unsupported flags */ 433 + if (perout->flags) 434 + return -EOPNOTSUPP; 435 + 432 436 if (!on) { 433 437 lan743x_ptp_perout_off(adapter); 434 438 return 0;
+2 -1
drivers/net/ethernet/renesas/ravb.h
··· 955 955 #define NUM_RX_QUEUE 2 956 956 #define NUM_TX_QUEUE 2 957 957 958 + #define RX_BUF_SZ (2048 - ETH_FCS_LEN + sizeof(__sum16)) 959 + 958 960 /* TX descriptors per packet */ 959 961 #define NUM_TX_DESC_GEN2 2 960 962 #define NUM_TX_DESC_GEN3 1 ··· 1020 1018 u32 dirty_rx[NUM_RX_QUEUE]; /* Producer ring indices */ 1021 1019 u32 cur_tx[NUM_TX_QUEUE]; 1022 1020 u32 dirty_tx[NUM_TX_QUEUE]; 1023 - u32 rx_buf_sz; /* Based on MTU+slack. */ 1024 1021 struct napi_struct napi[NUM_RX_QUEUE]; 1025 1022 struct work_struct work; 1026 1023 /* MII transceiver section. */
+14 -12
drivers/net/ethernet/renesas/ravb_main.c
··· 230 230 le32_to_cpu(desc->dptr))) 231 231 dma_unmap_single(ndev->dev.parent, 232 232 le32_to_cpu(desc->dptr), 233 - priv->rx_buf_sz, 233 + RX_BUF_SZ, 234 234 DMA_FROM_DEVICE); 235 235 } 236 236 ring_size = sizeof(struct ravb_ex_rx_desc) * ··· 293 293 for (i = 0; i < priv->num_rx_ring[q]; i++) { 294 294 /* RX descriptor */ 295 295 rx_desc = &priv->rx_ring[q][i]; 296 - rx_desc->ds_cc = cpu_to_le16(priv->rx_buf_sz); 296 + rx_desc->ds_cc = cpu_to_le16(RX_BUF_SZ); 297 297 dma_addr = dma_map_single(ndev->dev.parent, priv->rx_skb[q][i]->data, 298 - priv->rx_buf_sz, 298 + RX_BUF_SZ, 299 299 DMA_FROM_DEVICE); 300 300 /* We just set the data size to 0 for a failed mapping which 301 301 * should prevent DMA from happening... ··· 342 342 int ring_size; 343 343 int i; 344 344 345 - priv->rx_buf_sz = (ndev->mtu <= 1492 ? PKT_BUF_SZ : ndev->mtu) + 346 - ETH_HLEN + VLAN_HLEN + sizeof(__sum16); 347 - 348 345 /* Allocate RX and TX skb rings */ 349 346 priv->rx_skb[q] = kcalloc(priv->num_rx_ring[q], 350 347 sizeof(*priv->rx_skb[q]), GFP_KERNEL); ··· 351 354 goto error; 352 355 353 356 for (i = 0; i < priv->num_rx_ring[q]; i++) { 354 - skb = netdev_alloc_skb(ndev, priv->rx_buf_sz + RAVB_ALIGN - 1); 357 + skb = netdev_alloc_skb(ndev, RX_BUF_SZ + RAVB_ALIGN - 1); 355 358 if (!skb) 356 359 goto error; 357 360 ravb_set_buffer_align(skb); ··· 581 584 skb = priv->rx_skb[q][entry]; 582 585 priv->rx_skb[q][entry] = NULL; 583 586 dma_unmap_single(ndev->dev.parent, le32_to_cpu(desc->dptr), 584 - priv->rx_buf_sz, 587 + RX_BUF_SZ, 585 588 DMA_FROM_DEVICE); 586 589 get_ts &= (q == RAVB_NC) ? 587 590 RAVB_RXTSTAMP_TYPE_V2_L2_EVENT : ··· 614 617 for (; priv->cur_rx[q] - priv->dirty_rx[q] > 0; priv->dirty_rx[q]++) { 615 618 entry = priv->dirty_rx[q] % priv->num_rx_ring[q]; 616 619 desc = &priv->rx_ring[q][entry]; 617 - desc->ds_cc = cpu_to_le16(priv->rx_buf_sz); 620 + desc->ds_cc = cpu_to_le16(RX_BUF_SZ); 618 621 619 622 if (!priv->rx_skb[q][entry]) { 620 623 skb = netdev_alloc_skb(ndev, 621 - priv->rx_buf_sz + 624 + RX_BUF_SZ + 622 625 RAVB_ALIGN - 1); 623 626 if (!skb) 624 627 break; /* Better luck next round. */ ··· 1798 1801 1799 1802 static int ravb_change_mtu(struct net_device *ndev, int new_mtu) 1800 1803 { 1801 - if (netif_running(ndev)) 1802 - return -EBUSY; 1804 + struct ravb_private *priv = netdev_priv(ndev); 1803 1805 1804 1806 ndev->mtu = new_mtu; 1807 + 1808 + if (netif_running(ndev)) { 1809 + synchronize_irq(priv->emac_irq); 1810 + ravb_emac_init(ndev); 1811 + } 1812 + 1805 1813 netdev_update_features(ndev); 1806 1814 1807 1815 return 0;
+11
drivers/net/ethernet/renesas/ravb_ptp.c
··· 182 182 struct net_device *ndev = priv->ndev; 183 183 unsigned long flags; 184 184 185 + /* Reject requests with unsupported flags */ 186 + if (req->flags & ~(PTP_ENABLE_FEATURE | 187 + PTP_RISING_EDGE | 188 + PTP_FALLING_EDGE | 189 + PTP_STRICT_FLAGS)) 190 + return -EOPNOTSUPP; 191 + 185 192 if (req->index) 186 193 return -EINVAL; 187 194 ··· 217 210 struct ravb_ptp_perout *perout; 218 211 unsigned long flags; 219 212 int error = 0; 213 + 214 + /* Reject requests with unsupported flags */ 215 + if (req->flags) 216 + return -EOPNOTSUPP; 220 217 221 218 if (req->index) 222 219 return -EINVAL;
+1 -1
drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c
··· 1226 1226 dwmac_mux: 1227 1227 sun8i_dwmac_unset_syscon(gmac); 1228 1228 dwmac_exit: 1229 - sun8i_dwmac_exit(pdev, plat_dat->bsp_priv); 1229 + stmmac_pltfr_remove(pdev); 1230 1230 return ret; 1231 1231 } 1232 1232
+1 -1
drivers/net/ethernet/stmicro/stmmac/dwmac5.h
··· 1 - // SPDX-License-Identifier: (GPL-2.0 OR MIT) 1 + /* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ 2 2 // Copyright (c) 2017 Synopsys, Inc. and/or its affiliates. 3 3 // stmmac Support for 5.xx Ethernet QoS cores 4 4
+1 -1
drivers/net/ethernet/stmicro/stmmac/dwxgmac2.h
··· 1 - // SPDX-License-Identifier: (GPL-2.0 OR MIT) 1 + /* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ 2 2 /* 3 3 * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. 4 4 * stmmac XGMAC definitions.
+1 -1
drivers/net/ethernet/stmicro/stmmac/hwif.h
··· 1 - // SPDX-License-Identifier: (GPL-2.0 OR MIT) 1 + /* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ 2 2 // Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. 3 3 // stmmac HW Interface Callbacks 4 4
+4
drivers/net/ethernet/stmicro/stmmac/stmmac_ptp.c
··· 140 140 141 141 switch (rq->type) { 142 142 case PTP_CLK_REQ_PEROUT: 143 + /* Reject requests with unsupported flags */ 144 + if (rq->perout.flags) 145 + return -EOPNOTSUPP; 146 + 143 147 cfg = &priv->pps[rq->perout.index]; 144 148 145 149 cfg->start.tv_sec = rq->perout.start.sec;
+2
drivers/net/netdevsim/dev.c
··· 708 708 goto err_debugfs_exit; 709 709 710 710 devlink_params_publish(devlink); 711 + devlink_reload_enable(devlink); 711 712 return nsim_dev; 712 713 713 714 err_debugfs_exit: ··· 733 732 { 734 733 struct devlink *devlink = priv_to_devlink(nsim_dev); 735 734 735 + devlink_reload_disable(devlink); 736 736 nsim_bpf_dev_exit(nsim_dev); 737 737 nsim_dev_debugfs_exit(nsim_dev); 738 738 nsim_dev_traps_exit(devlink);
+16
drivers/net/phy/dp83640.c
··· 469 469 470 470 switch (rq->type) { 471 471 case PTP_CLK_REQ_EXTTS: 472 + /* Reject requests with unsupported flags */ 473 + if (rq->extts.flags & ~(PTP_ENABLE_FEATURE | 474 + PTP_RISING_EDGE | 475 + PTP_FALLING_EDGE | 476 + PTP_STRICT_FLAGS)) 477 + return -EOPNOTSUPP; 478 + 479 + /* Reject requests to enable time stamping on both edges. */ 480 + if ((rq->extts.flags & PTP_STRICT_FLAGS) && 481 + (rq->extts.flags & PTP_ENABLE_FEATURE) && 482 + (rq->extts.flags & PTP_EXTTS_EDGES) == PTP_EXTTS_EDGES) 483 + return -EOPNOTSUPP; 484 + 472 485 index = rq->extts.index; 473 486 if (index >= N_EXT_TS) 474 487 return -EINVAL; ··· 504 491 return 0; 505 492 506 493 case PTP_CLK_REQ_PEROUT: 494 + /* Reject requests with unsupported flags */ 495 + if (rq->perout.flags) 496 + return -EOPNOTSUPP; 507 497 if (rq->perout.index >= N_PER_OUT) 508 498 return -EINVAL; 509 499 return periodic_output(clock, rq, on, rq->perout.index);
+6 -5
drivers/net/phy/mdio_bus.c
··· 64 64 if (mdiodev->dev.of_node) 65 65 reset = devm_reset_control_get_exclusive(&mdiodev->dev, 66 66 "phy"); 67 - if (PTR_ERR(reset) == -ENOENT || 68 - PTR_ERR(reset) == -ENOTSUPP) 69 - reset = NULL; 70 - else if (IS_ERR(reset)) 71 - return PTR_ERR(reset); 67 + if (IS_ERR(reset)) { 68 + if (PTR_ERR(reset) == -ENOENT || PTR_ERR(reset) == -ENOSYS) 69 + reset = NULL; 70 + else 71 + return PTR_ERR(reset); 72 + } 72 73 73 74 mdiodev->reset_ctrl = reset; 74 75
+1
drivers/net/slip/slip.c
··· 855 855 sl->tty = NULL; 856 856 tty->disc_data = NULL; 857 857 clear_bit(SLF_INUSE, &sl->flags); 858 + free_netdev(sl->dev); 858 859 859 860 err_exit: 860 861 rtnl_unlock();
+1 -1
drivers/net/usb/ax88172a.c
··· 196 196 197 197 /* Get the MAC address */ 198 198 ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf, 0); 199 - if (ret < 0) { 199 + if (ret < ETH_ALEN) { 200 200 netdev_err(dev->net, "Failed to read MAC address: %d\n", ret); 201 201 goto free; 202 202 }
+1 -1
drivers/net/usb/cdc_ncm.c
··· 579 579 err = usbnet_read_cmd(dev, USB_CDC_GET_MAX_DATAGRAM_SIZE, 580 580 USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE, 581 581 0, iface_no, &max_datagram_size, sizeof(max_datagram_size)); 582 - if (err < sizeof(max_datagram_size)) { 582 + if (err != sizeof(max_datagram_size)) { 583 583 dev_dbg(&dev->intf->dev, "GET_MAX_DATAGRAM_SIZE failed\n"); 584 584 goto out; 585 585 }
+2
drivers/net/usb/qmi_wwan.c
··· 1371 1371 {QMI_QUIRK_SET_DTR(0x2c7c, 0x0191, 4)}, /* Quectel EG91 */ 1372 1372 {QMI_FIXED_INTF(0x2c7c, 0x0296, 4)}, /* Quectel BG96 */ 1373 1373 {QMI_QUIRK_SET_DTR(0x2cb7, 0x0104, 4)}, /* Fibocom NL678 series */ 1374 + {QMI_FIXED_INTF(0x0489, 0xe0b4, 0)}, /* Foxconn T77W968 LTE */ 1375 + {QMI_FIXED_INTF(0x0489, 0xe0b5, 0)}, /* Foxconn T77W968 LTE with eSIM support*/ 1374 1376 1375 1377 /* 4. Gobi 1000 devices */ 1376 1378 {QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */
+7 -13
drivers/net/wireless/intel/iwlwifi/pcie/tx-gen2.c
··· 251 251 struct ieee80211_hdr *hdr = (void *)skb->data; 252 252 unsigned int snap_ip_tcp_hdrlen, ip_hdrlen, total_len, hdr_room; 253 253 unsigned int mss = skb_shinfo(skb)->gso_size; 254 - u16 length, iv_len, amsdu_pad; 254 + u16 length, amsdu_pad; 255 255 u8 *start_hdr; 256 256 struct iwl_tso_hdr_page *hdr_page; 257 257 struct page **page_ptr; 258 258 struct tso_t tso; 259 - 260 - /* if the packet is protected, then it must be CCMP or GCMP */ 261 - iv_len = ieee80211_has_protected(hdr->frame_control) ? 262 - IEEE80211_CCMP_HDR_LEN : 0; 263 259 264 260 trace_iwlwifi_dev_tx(trans->dev, skb, tfd, sizeof(*tfd), 265 261 &dev_cmd->hdr, start_len, 0); 266 262 267 263 ip_hdrlen = skb_transport_header(skb) - skb_network_header(skb); 268 264 snap_ip_tcp_hdrlen = 8 + ip_hdrlen + tcp_hdrlen(skb); 269 - total_len = skb->len - snap_ip_tcp_hdrlen - hdr_len - iv_len; 265 + total_len = skb->len - snap_ip_tcp_hdrlen - hdr_len; 270 266 amsdu_pad = 0; 271 267 272 268 /* total amount of header we may need for this A-MSDU */ 273 269 hdr_room = DIV_ROUND_UP(total_len, mss) * 274 - (3 + snap_ip_tcp_hdrlen + sizeof(struct ethhdr)) + iv_len; 270 + (3 + snap_ip_tcp_hdrlen + sizeof(struct ethhdr)); 275 271 276 272 /* Our device supports 9 segments at most, it will fit in 1 page */ 277 273 hdr_page = get_page_hdr(trans, hdr_room); ··· 278 282 start_hdr = hdr_page->pos; 279 283 page_ptr = (void *)((u8 *)skb->cb + trans_pcie->page_offs); 280 284 *page_ptr = hdr_page->page; 281 - memcpy(hdr_page->pos, skb->data + hdr_len, iv_len); 282 - hdr_page->pos += iv_len; 283 285 284 286 /* 285 - * Pull the ieee80211 header + IV to be able to use TSO core, 287 + * Pull the ieee80211 header to be able to use TSO core, 286 288 * we will restore it for the tx_status flow. 287 289 */ 288 - skb_pull(skb, hdr_len + iv_len); 290 + skb_pull(skb, hdr_len); 289 291 290 292 /* 291 293 * Remove the length of all the headers that we don't actually ··· 358 364 } 359 365 } 360 366 361 - /* re -add the WiFi header and IV */ 362 - skb_push(skb, hdr_len + iv_len); 367 + /* re -add the WiFi header */ 368 + skb_push(skb, hdr_len); 363 369 364 370 return 0; 365 371
+4 -2
drivers/nfc/nxp-nci/i2c.c
··· 220 220 221 221 if (r == -EREMOTEIO) { 222 222 phy->hard_fault = r; 223 - skb = NULL; 224 - } else if (r < 0) { 223 + if (info->mode == NXP_NCI_MODE_FW) 224 + nxp_nci_fw_recv_frame(phy->ndev, NULL); 225 + } 226 + if (r < 0) { 225 227 nfc_err(&client->dev, "Read failed with error %d\n", r); 226 228 goto exit_irq_handled; 227 229 }
+15 -5
drivers/ptp/ptp_chardev.c
··· 149 149 err = -EFAULT; 150 150 break; 151 151 } 152 - if (((req.extts.flags & ~PTP_EXTTS_VALID_FLAGS) || 153 - req.extts.rsv[0] || req.extts.rsv[1]) && 154 - cmd == PTP_EXTTS_REQUEST2) { 155 - err = -EINVAL; 156 - break; 152 + if (cmd == PTP_EXTTS_REQUEST2) { 153 + /* Tell the drivers to check the flags carefully. */ 154 + req.extts.flags |= PTP_STRICT_FLAGS; 155 + /* Make sure no reserved bit is set. */ 156 + if ((req.extts.flags & ~PTP_EXTTS_VALID_FLAGS) || 157 + req.extts.rsv[0] || req.extts.rsv[1]) { 158 + err = -EINVAL; 159 + break; 160 + } 161 + /* Ensure one of the rising/falling edge bits is set. */ 162 + if ((req.extts.flags & PTP_ENABLE_FEATURE) && 163 + (req.extts.flags & PTP_EXTTS_EDGES) == 0) { 164 + err = -EINVAL; 165 + break; 166 + } 157 167 } else if (cmd == PTP_EXTTS_REQUEST) { 158 168 req.extts.flags &= PTP_EXTTS_V1_VALID_FLAGS; 159 169 req.extts.rsv[0] = 0;
+1
include/linux/can/core.h
··· 65 65 void *data); 66 66 67 67 extern int can_send(struct sk_buff *skb, int loop); 68 + void can_sock_destruct(struct sock *sk); 68 69 69 70 #endif /* !_CAN_CORE_H */
+4 -1
include/net/devlink.h
··· 38 38 struct device *dev; 39 39 possible_net_t _net; 40 40 struct mutex lock; 41 - bool reload_failed; 41 + u8 reload_failed:1, 42 + reload_enabled:1; 42 43 char priv[0] __aligned(NETDEV_ALIGN); 43 44 }; 44 45 ··· 775 774 struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size); 776 775 int devlink_register(struct devlink *devlink, struct device *dev); 777 776 void devlink_unregister(struct devlink *devlink); 777 + void devlink_reload_enable(struct devlink *devlink); 778 + void devlink_reload_disable(struct devlink *devlink); 778 779 void devlink_free(struct devlink *devlink); 779 780 int devlink_port_register(struct devlink *devlink, 780 781 struct devlink_port *devlink_port,
+1 -1
include/trace/events/tcp.h
··· 86 86 sk->sk_v6_rcv_saddr, sk->sk_v6_daddr); 87 87 ), 88 88 89 - TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c state=%s\n", 89 + TP_printk("sport=%hu dport=%hu saddr=%pI4 daddr=%pI4 saddrv6=%pI6c daddrv6=%pI6c state=%s", 90 90 __entry->sport, __entry->dport, __entry->saddr, __entry->daddr, 91 91 __entry->saddr_v6, __entry->daddr_v6, 92 92 show_tcp_state_name(__entry->state))
+1
include/uapi/linux/devlink.h
··· 421 421 422 422 DEVLINK_ATTR_RELOAD_FAILED, /* u8 0 or 1 */ 423 423 424 + DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS, /* u64 */ 424 425 /* add new attributes above here, update the policy in devlink.c */ 425 426 426 427 __DEVLINK_ATTR_MAX,
+4 -1
include/uapi/linux/ptp_clock.h
··· 31 31 #define PTP_ENABLE_FEATURE (1<<0) 32 32 #define PTP_RISING_EDGE (1<<1) 33 33 #define PTP_FALLING_EDGE (1<<2) 34 + #define PTP_STRICT_FLAGS (1<<3) 35 + #define PTP_EXTTS_EDGES (PTP_RISING_EDGE | PTP_FALLING_EDGE) 34 36 35 37 /* 36 38 * flag fields valid for the new PTP_EXTTS_REQUEST2 ioctl. 37 39 */ 38 40 #define PTP_EXTTS_VALID_FLAGS (PTP_ENABLE_FEATURE | \ 39 41 PTP_RISING_EDGE | \ 40 - PTP_FALLING_EDGE) 42 + PTP_FALLING_EDGE | \ 43 + PTP_STRICT_FLAGS) 41 44 42 45 /* 43 46 * flag fields valid for the original PTP_EXTTS_REQUEST ioctl.
+2 -1
net/can/af_can.c
··· 86 86 87 87 /* af_can socket functions */ 88 88 89 - static void can_sock_destruct(struct sock *sk) 89 + void can_sock_destruct(struct sock *sk) 90 90 { 91 91 skb_queue_purge(&sk->sk_receive_queue); 92 92 skb_queue_purge(&sk->sk_error_queue); 93 93 } 94 + EXPORT_SYMBOL(can_sock_destruct); 94 95 95 96 static const struct can_proto *can_get_proto(int protocol) 96 97 {
+9
net/can/j1939/main.c
··· 51 51 if (!skb) 52 52 return; 53 53 54 + j1939_priv_get(priv); 54 55 can_skb_set_owner(skb, iskb->sk); 55 56 56 57 /* get a pointer to the header of the skb ··· 105 104 j1939_simple_recv(priv, skb); 106 105 j1939_sk_recv(priv, skb); 107 106 done: 107 + j1939_priv_put(priv); 108 108 kfree_skb(skb); 109 109 } 110 110 ··· 151 149 struct net_device *ndev = priv->ndev; 152 150 153 151 netdev_dbg(priv->ndev, "%s: 0x%p\n", __func__, priv); 152 + 153 + WARN_ON_ONCE(!list_empty(&priv->active_session_list)); 154 + WARN_ON_ONCE(!list_empty(&priv->ecus)); 155 + WARN_ON_ONCE(!list_empty(&priv->j1939_socks)); 154 156 155 157 dev_put(ndev); 156 158 kfree(priv); ··· 212 206 static inline struct j1939_priv *j1939_ndev_to_priv(struct net_device *ndev) 213 207 { 214 208 struct can_ml_priv *can_ml_priv = ndev->ml_priv; 209 + 210 + if (!can_ml_priv) 211 + return NULL; 215 212 216 213 return can_ml_priv->j1939_priv; 217 214 }
+74 -20
net/can/j1939/socket.c
··· 78 78 { 79 79 jsk->state |= J1939_SOCK_BOUND; 80 80 j1939_priv_get(priv); 81 - jsk->priv = priv; 82 81 83 82 spin_lock_bh(&priv->j1939_socks_lock); 84 83 list_add_tail(&jsk->list, &priv->j1939_socks); ··· 90 91 list_del_init(&jsk->list); 91 92 spin_unlock_bh(&priv->j1939_socks_lock); 92 93 93 - jsk->priv = NULL; 94 94 j1939_priv_put(priv); 95 95 jsk->state &= ~J1939_SOCK_BOUND; 96 96 } ··· 347 349 spin_unlock_bh(&priv->j1939_socks_lock); 348 350 } 349 351 352 + static void j1939_sk_sock_destruct(struct sock *sk) 353 + { 354 + struct j1939_sock *jsk = j1939_sk(sk); 355 + 356 + /* This function will be call by the generic networking code, when then 357 + * the socket is ultimately closed (sk->sk_destruct). 358 + * 359 + * The race between 360 + * - processing a received CAN frame 361 + * (can_receive -> j1939_can_recv) 362 + * and accessing j1939_priv 363 + * ... and ... 364 + * - closing a socket 365 + * (j1939_can_rx_unregister -> can_rx_unregister) 366 + * and calling the final j1939_priv_put() 367 + * 368 + * is avoided by calling the final j1939_priv_put() from this 369 + * RCU deferred cleanup call. 370 + */ 371 + if (jsk->priv) { 372 + j1939_priv_put(jsk->priv); 373 + jsk->priv = NULL; 374 + } 375 + 376 + /* call generic CAN sock destruct */ 377 + can_sock_destruct(sk); 378 + } 379 + 350 380 static int j1939_sk_init(struct sock *sk) 351 381 { 352 382 struct j1939_sock *jsk = j1939_sk(sk); ··· 397 371 atomic_set(&jsk->skb_pending, 0); 398 372 spin_lock_init(&jsk->sk_session_queue_lock); 399 373 INIT_LIST_HEAD(&jsk->sk_session_queue); 374 + sk->sk_destruct = j1939_sk_sock_destruct; 400 375 401 376 return 0; 402 377 } ··· 470 443 } 471 444 472 445 jsk->ifindex = addr->can_ifindex; 446 + 447 + /* the corresponding j1939_priv_put() is called via 448 + * sk->sk_destruct, which points to j1939_sk_sock_destruct() 449 + */ 450 + j1939_priv_get(priv); 451 + jsk->priv = priv; 473 452 } 474 453 475 454 /* set default transmit pgn */ ··· 593 560 if (!sk) 594 561 return 0; 595 562 596 - jsk = j1939_sk(sk); 597 563 lock_sock(sk); 564 + jsk = j1939_sk(sk); 598 565 599 566 if (jsk->state & J1939_SOCK_BOUND) { 600 567 struct j1939_priv *priv = jsk->priv; ··· 1092 1059 { 1093 1060 struct sock *sk = sock->sk; 1094 1061 struct j1939_sock *jsk = j1939_sk(sk); 1095 - struct j1939_priv *priv = jsk->priv; 1062 + struct j1939_priv *priv; 1096 1063 int ifindex; 1097 1064 int ret; 1098 1065 1066 + lock_sock(sock->sk); 1099 1067 /* various socket state tests */ 1100 - if (!(jsk->state & J1939_SOCK_BOUND)) 1101 - return -EBADFD; 1068 + if (!(jsk->state & J1939_SOCK_BOUND)) { 1069 + ret = -EBADFD; 1070 + goto sendmsg_done; 1071 + } 1102 1072 1073 + priv = jsk->priv; 1103 1074 ifindex = jsk->ifindex; 1104 1075 1105 - if (!jsk->addr.src_name && jsk->addr.sa == J1939_NO_ADDR) 1076 + if (!jsk->addr.src_name && jsk->addr.sa == J1939_NO_ADDR) { 1106 1077 /* no source address assigned yet */ 1107 - return -EBADFD; 1078 + ret = -EBADFD; 1079 + goto sendmsg_done; 1080 + } 1108 1081 1109 1082 /* deal with provided destination address info */ 1110 1083 if (msg->msg_name) { 1111 1084 struct sockaddr_can *addr = msg->msg_name; 1112 1085 1113 - if (msg->msg_namelen < J1939_MIN_NAMELEN) 1114 - return -EINVAL; 1086 + if (msg->msg_namelen < J1939_MIN_NAMELEN) { 1087 + ret = -EINVAL; 1088 + goto sendmsg_done; 1089 + } 1115 1090 1116 - if (addr->can_family != AF_CAN) 1117 - return -EINVAL; 1091 + if (addr->can_family != AF_CAN) { 1092 + ret = -EINVAL; 1093 + goto sendmsg_done; 1094 + } 1118 1095 1119 - if (addr->can_ifindex && addr->can_ifindex != ifindex) 1120 - return -EBADFD; 1096 + if (addr->can_ifindex && addr->can_ifindex != ifindex) { 1097 + ret = -EBADFD; 1098 + goto sendmsg_done; 1099 + } 1121 1100 1122 1101 if (j1939_pgn_is_valid(addr->can_addr.j1939.pgn) && 1123 - !j1939_pgn_is_clean_pdu(addr->can_addr.j1939.pgn)) 1124 - return -EINVAL; 1102 + !j1939_pgn_is_clean_pdu(addr->can_addr.j1939.pgn)) { 1103 + ret = -EINVAL; 1104 + goto sendmsg_done; 1105 + } 1125 1106 1126 1107 if (!addr->can_addr.j1939.name && 1127 1108 addr->can_addr.j1939.addr == J1939_NO_ADDR && 1128 - !sock_flag(sk, SOCK_BROADCAST)) 1109 + !sock_flag(sk, SOCK_BROADCAST)) { 1129 1110 /* broadcast, but SO_BROADCAST not set */ 1130 - return -EACCES; 1111 + ret = -EACCES; 1112 + goto sendmsg_done; 1113 + } 1131 1114 } else { 1132 1115 if (!jsk->addr.dst_name && jsk->addr.da == J1939_NO_ADDR && 1133 - !sock_flag(sk, SOCK_BROADCAST)) 1116 + !sock_flag(sk, SOCK_BROADCAST)) { 1134 1117 /* broadcast, but SO_BROADCAST not set */ 1135 - return -EACCES; 1118 + ret = -EACCES; 1119 + goto sendmsg_done; 1120 + } 1136 1121 } 1137 1122 1138 1123 ret = j1939_sk_send_loop(priv, sk, msg, size); 1124 + 1125 + sendmsg_done: 1126 + release_sock(sock->sk); 1139 1127 1140 1128 return ret; 1141 1129 }
+27 -9
net/can/j1939/transport.c
··· 255 255 return; 256 256 257 257 j1939_sock_pending_del(session->sk); 258 + sock_put(session->sk); 258 259 } 259 260 260 261 static void j1939_session_destroy(struct j1939_session *session) ··· 266 265 j1939_sk_errqueue(session, J1939_ERRQUEUE_ACK); 267 266 268 267 netdev_dbg(session->priv->ndev, "%s: 0x%p\n", __func__, session); 268 + 269 + WARN_ON_ONCE(!list_empty(&session->sk_session_queue_entry)); 270 + WARN_ON_ONCE(!list_empty(&session->active_session_list_entry)); 269 271 270 272 skb_queue_purge(&session->skb_queue); 271 273 __j1939_session_drop(session); ··· 1046 1042 j1939_sk_queue_activate_next(session); 1047 1043 } 1048 1044 1049 - static void j1939_session_cancel(struct j1939_session *session, 1045 + static void __j1939_session_cancel(struct j1939_session *session, 1050 1046 enum j1939_xtp_abort err) 1051 1047 { 1052 1048 struct j1939_priv *priv = session->priv; 1053 1049 1054 1050 WARN_ON_ONCE(!err); 1051 + lockdep_assert_held(&session->priv->active_session_list_lock); 1055 1052 1056 1053 session->err = j1939_xtp_abort_to_errno(priv, err); 1057 1054 /* do not send aborts on incoming broadcasts */ ··· 1065 1060 1066 1061 if (session->sk) 1067 1062 j1939_sk_send_loop_abort(session->sk, session->err); 1063 + } 1064 + 1065 + static void j1939_session_cancel(struct j1939_session *session, 1066 + enum j1939_xtp_abort err) 1067 + { 1068 + j1939_session_list_lock(session->priv); 1069 + 1070 + if (session->state >= J1939_SESSION_ACTIVE && 1071 + session->state < J1939_SESSION_WAITING_ABORT) { 1072 + j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS); 1073 + __j1939_session_cancel(session, err); 1074 + } 1075 + 1076 + j1939_session_list_unlock(session->priv); 1068 1077 } 1069 1078 1070 1079 static enum hrtimer_restart j1939_tp_txtimer(struct hrtimer *hrtimer) ··· 1127 1108 netdev_alert(priv->ndev, "%s: 0x%p: tx aborted with unknown reason: %i\n", 1128 1109 __func__, session, ret); 1129 1110 if (session->skcb.addr.type != J1939_SIMPLE) { 1130 - j1939_tp_set_rxtimeout(session, 1131 - J1939_XTP_ABORT_TIMEOUT_MS); 1132 1111 j1939_session_cancel(session, J1939_XTP_ABORT_OTHER); 1133 1112 } else { 1134 1113 session->err = ret; ··· 1186 1169 hrtimer_start(&session->rxtimer, 1187 1170 ms_to_ktime(J1939_XTP_ABORT_TIMEOUT_MS), 1188 1171 HRTIMER_MODE_REL_SOFT); 1189 - j1939_session_cancel(session, J1939_XTP_ABORT_TIMEOUT); 1172 + __j1939_session_cancel(session, J1939_XTP_ABORT_TIMEOUT); 1190 1173 } 1191 1174 j1939_session_list_unlock(session->priv); 1192 1175 } ··· 1392 1375 1393 1376 out_session_cancel: 1394 1377 j1939_session_timers_cancel(session); 1395 - j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS); 1396 1378 j1939_session_cancel(session, err); 1397 1379 } 1398 1380 ··· 1588 1572 1589 1573 /* RTS on active session */ 1590 1574 j1939_session_timers_cancel(session); 1591 - j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS); 1592 1575 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY); 1593 1576 } 1594 1577 ··· 1598 1583 session->last_cmd); 1599 1584 1600 1585 j1939_session_timers_cancel(session); 1601 - j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS); 1602 1586 j1939_session_cancel(session, J1939_XTP_ABORT_BUSY); 1603 1587 1604 1588 return -EBUSY; ··· 1799 1785 1800 1786 out_session_cancel: 1801 1787 j1939_session_timers_cancel(session); 1802 - j1939_tp_set_rxtimeout(session, J1939_XTP_ABORT_TIMEOUT_MS); 1803 1788 j1939_session_cancel(session, J1939_XTP_ABORT_FAULT); 1804 1789 j1939_session_put(session); 1805 1790 } ··· 1879 1866 return ERR_PTR(-ENOMEM); 1880 1867 1881 1868 /* skb is recounted in j1939_session_new() */ 1869 + sock_hold(skb->sk); 1882 1870 session->sk = skb->sk; 1883 1871 session->transmission = true; 1884 1872 session->pkt.total = (size + 6) / 7; ··· 2042 2028 &priv->active_session_list, 2043 2029 active_session_list_entry) { 2044 2030 if (!sk || sk == session->sk) { 2045 - j1939_session_timers_cancel(session); 2031 + if (hrtimer_try_to_cancel(&session->txtimer) == 1) 2032 + j1939_session_put(session); 2033 + if (hrtimer_try_to_cancel(&session->rxtimer) == 1) 2034 + j1939_session_put(session); 2035 + 2046 2036 session->err = ESHUTDOWN; 2047 2037 j1939_session_deactivate_locked(session); 2048 2038 }
+44 -1
net/core/devlink.c
··· 2699 2699 struct devlink *devlink = info->user_ptr[0]; 2700 2700 int err; 2701 2701 2702 - if (!devlink_reload_supported(devlink)) 2702 + if (!devlink_reload_supported(devlink) || !devlink->reload_enabled) 2703 2703 return -EOPNOTSUPP; 2704 2704 2705 2705 err = devlink_resources_validate(devlink, NULL, info); ··· 4618 4618 bool auto_recover; 4619 4619 u8 health_state; 4620 4620 u64 dump_ts; 4621 + u64 dump_real_ts; 4621 4622 u64 error_count; 4622 4623 u64 recovery_count; 4623 4624 u64 last_recovery_ts; ··· 4791 4790 goto dump_err; 4792 4791 4793 4792 reporter->dump_ts = jiffies; 4793 + reporter->dump_real_ts = ktime_get_real_ns(); 4794 4794 4795 4795 return 0; 4796 4796 ··· 4953 4951 nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS, 4954 4952 jiffies_to_msecs(reporter->dump_ts), 4955 4953 DEVLINK_ATTR_PAD)) 4954 + goto reporter_nest_cancel; 4955 + if (reporter->dump_fmsg && 4956 + nla_put_u64_64bit(msg, DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS, 4957 + reporter->dump_real_ts, DEVLINK_ATTR_PAD)) 4956 4958 goto reporter_nest_cancel; 4957 4959 4958 4960 nla_nest_end(msg, reporter_attr); ··· 6202 6196 void devlink_unregister(struct devlink *devlink) 6203 6197 { 6204 6198 mutex_lock(&devlink_mutex); 6199 + WARN_ON(devlink_reload_supported(devlink) && 6200 + devlink->reload_enabled); 6205 6201 devlink_notify(devlink, DEVLINK_CMD_DEL); 6206 6202 list_del(&devlink->list); 6207 6203 mutex_unlock(&devlink_mutex); 6208 6204 } 6209 6205 EXPORT_SYMBOL_GPL(devlink_unregister); 6206 + 6207 + /** 6208 + * devlink_reload_enable - Enable reload of devlink instance 6209 + * 6210 + * @devlink: devlink 6211 + * 6212 + * Should be called at end of device initialization 6213 + * process when reload operation is supported. 6214 + */ 6215 + void devlink_reload_enable(struct devlink *devlink) 6216 + { 6217 + mutex_lock(&devlink_mutex); 6218 + devlink->reload_enabled = true; 6219 + mutex_unlock(&devlink_mutex); 6220 + } 6221 + EXPORT_SYMBOL_GPL(devlink_reload_enable); 6222 + 6223 + /** 6224 + * devlink_reload_disable - Disable reload of devlink instance 6225 + * 6226 + * @devlink: devlink 6227 + * 6228 + * Should be called at the beginning of device cleanup 6229 + * process when reload operation is supported. 6230 + */ 6231 + void devlink_reload_disable(struct devlink *devlink) 6232 + { 6233 + mutex_lock(&devlink_mutex); 6234 + /* Mutex is taken which ensures that no reload operation is in 6235 + * progress while setting up forbidded flag. 6236 + */ 6237 + devlink->reload_enabled = false; 6238 + mutex_unlock(&devlink_mutex); 6239 + } 6240 + EXPORT_SYMBOL_GPL(devlink_reload_disable); 6210 6241 6211 6242 /** 6212 6243 * devlink_free - Free devlink instance resources
+1 -1
net/dsa/tag_8021q.c
··· 106 106 slave = ds->ports[port].slave; 107 107 108 108 err = br_vlan_get_pvid(slave, &pvid); 109 - if (err < 0) 109 + if (!pvid || err < 0) 110 110 /* There is no pvid on the bridge for this port, which is 111 111 * perfectly valid. Nothing to restore, bye-bye! 112 112 */
+2 -1
net/ipv4/ipmr.c
··· 2289 2289 rcu_read_unlock(); 2290 2290 return -ENODEV; 2291 2291 } 2292 - skb2 = skb_clone(skb, GFP_ATOMIC); 2292 + 2293 + skb2 = skb_realloc_headroom(skb, sizeof(struct iphdr)); 2293 2294 if (!skb2) { 2294 2295 read_unlock(&mrt_lock); 2295 2296 rcu_read_unlock();
+11
net/ipv6/seg6_local.c
··· 81 81 if (!pskb_may_pull(skb, srhoff + len)) 82 82 return NULL; 83 83 84 + /* note that pskb_may_pull may change pointers in header; 85 + * for this reason it is necessary to reload them when needed. 86 + */ 87 + srh = (struct ipv6_sr_hdr *)(skb->data + srhoff); 88 + 84 89 if (!seg6_validate_srh(srh, len)) 85 90 return NULL; 86 91 ··· 341 336 if (!ipv6_addr_any(&slwt->nh6)) 342 337 nhaddr = &slwt->nh6; 343 338 339 + skb_set_transport_header(skb, sizeof(struct ipv6hdr)); 340 + 344 341 seg6_lookup_nexthop(skb, nhaddr, 0); 345 342 346 343 return dst_input(skb); ··· 372 365 373 366 skb_dst_drop(skb); 374 367 368 + skb_set_transport_header(skb, sizeof(struct iphdr)); 369 + 375 370 err = ip_route_input(skb, nhaddr, iph->saddr, 0, skb->dev); 376 371 if (err) 377 372 goto drop; ··· 393 384 394 385 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 395 386 goto drop; 387 + 388 + skb_set_transport_header(skb, sizeof(struct ipv6hdr)); 396 389 397 390 seg6_lookup_nexthop(skb, NULL, slwt->table); 398 391
+15 -8
net/rds/ib_cm.c
··· 450 450 struct ib_qp_init_attr attr; 451 451 struct ib_cq_init_attr cq_attr = {}; 452 452 struct rds_ib_device *rds_ibdev; 453 + unsigned long max_wrs; 453 454 int ret, fr_queue_space; 454 455 455 456 /* ··· 470 469 /* add the conn now so that connection establishment has the dev */ 471 470 rds_ib_add_conn(rds_ibdev, conn); 472 471 473 - if (rds_ibdev->max_wrs < ic->i_send_ring.w_nr + 1) 474 - rds_ib_ring_resize(&ic->i_send_ring, rds_ibdev->max_wrs - 1); 475 - if (rds_ibdev->max_wrs < ic->i_recv_ring.w_nr + 1) 476 - rds_ib_ring_resize(&ic->i_recv_ring, rds_ibdev->max_wrs - 1); 472 + max_wrs = rds_ibdev->max_wrs < rds_ib_sysctl_max_send_wr + 1 ? 473 + rds_ibdev->max_wrs - 1 : rds_ib_sysctl_max_send_wr; 474 + if (ic->i_send_ring.w_nr != max_wrs) 475 + rds_ib_ring_resize(&ic->i_send_ring, max_wrs); 476 + 477 + max_wrs = rds_ibdev->max_wrs < rds_ib_sysctl_max_recv_wr + 1 ? 478 + rds_ibdev->max_wrs - 1 : rds_ib_sysctl_max_recv_wr; 479 + if (ic->i_recv_ring.w_nr != max_wrs) 480 + rds_ib_ring_resize(&ic->i_recv_ring, max_wrs); 477 481 478 482 /* Protection domain and memory range */ 479 483 ic->i_pd = rds_ibdev->pd; ··· 1105 1099 ic->i_flowctl = 0; 1106 1100 atomic_set(&ic->i_credits, 0); 1107 1101 1108 - rds_ib_ring_init(&ic->i_send_ring, rds_ib_sysctl_max_send_wr); 1109 - rds_ib_ring_init(&ic->i_recv_ring, rds_ib_sysctl_max_recv_wr); 1102 + /* Re-init rings, but retain sizes. */ 1103 + rds_ib_ring_init(&ic->i_send_ring, ic->i_send_ring.w_nr); 1104 + rds_ib_ring_init(&ic->i_recv_ring, ic->i_recv_ring.w_nr); 1110 1105 1111 1106 if (ic->i_ibinc) { 1112 1107 rds_inc_put(&ic->i_ibinc->ii_inc); ··· 1154 1147 * rds_ib_conn_shutdown() waits for these to be emptied so they 1155 1148 * must be initialized before it can be called. 1156 1149 */ 1157 - rds_ib_ring_init(&ic->i_send_ring, rds_ib_sysctl_max_send_wr); 1158 - rds_ib_ring_init(&ic->i_recv_ring, rds_ib_sysctl_max_recv_wr); 1150 + rds_ib_ring_init(&ic->i_send_ring, 0); 1151 + rds_ib_ring_init(&ic->i_recv_ring, 0); 1159 1152 1160 1153 ic->conn = conn; 1161 1154 conn->c_transport_data = ic;
+2 -1
net/smc/af_smc.c
··· 796 796 smc->sk.sk_err = EPIPE; 797 797 else if (signal_pending(current)) 798 798 smc->sk.sk_err = -sock_intr_errno(timeo); 799 + sock_put(&smc->sk); /* passive closing */ 799 800 goto out; 800 801 } 801 802 ··· 1732 1731 case TCP_FASTOPEN_KEY: 1733 1732 case TCP_FASTOPEN_NO_COOKIE: 1734 1733 /* option not supported by SMC */ 1735 - if (sk->sk_state == SMC_INIT) { 1734 + if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) { 1736 1735 smc_switch_to_fallback(smc); 1737 1736 smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP; 1738 1737 } else {
-2
net/tipc/core.c
··· 34 34 * POSSIBILITY OF SUCH DAMAGE. 35 35 */ 36 36 37 - #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 38 - 39 37 #include "core.h" 40 38 #include "name_table.h" 41 39 #include "subscr.h"
+6
net/tipc/core.h
··· 60 60 #include <linux/rhashtable.h> 61 61 #include <net/genetlink.h> 62 62 63 + #ifdef pr_fmt 64 + #undef pr_fmt 65 + #endif 66 + 67 + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 68 + 63 69 struct tipc_node; 64 70 struct tipc_bearer; 65 71 struct tipc_bc_base;
+3
net/xfrm/xfrm_input.c
··· 480 480 else 481 481 XFRM_INC_STATS(net, 482 482 LINUX_MIB_XFRMINSTATEINVALID); 483 + 484 + if (encap_type == -1) 485 + dev_put(skb->dev); 483 486 goto drop; 484 487 } 485 488
+2
net/xfrm/xfrm_state.c
··· 495 495 x->type->destructor(x); 496 496 xfrm_put_type(x->type); 497 497 } 498 + if (x->xfrag.page) 499 + put_page(x->xfrag.page); 498 500 xfrm_dev_state_free(x); 499 501 security_xfrm_state_free(x); 500 502 xfrm_state_free(x);
+6 -2
tools/testing/selftests/drivers/net/mlxsw/vxlan.sh
··· 112 112 RET=0 113 113 114 114 ip link add dev br0 type bridge mcast_snooping 0 115 + ip link add name dummy1 up type dummy 115 116 116 117 ip link add name vxlan0 up type vxlan id 10 nolearning noudpcsum \ 117 118 ttl 20 tos inherit local 198.51.100.1 dstport 4789 \ 118 - dev $swp2 group 239.0.0.1 119 + dev dummy1 group 239.0.0.1 119 120 120 121 sanitization_single_dev_test_fail 121 122 122 123 ip link del dev vxlan0 124 + ip link del dev dummy1 123 125 ip link del dev br0 124 126 125 127 log_test "vxlan device with a multicast group" ··· 183 181 RET=0 184 182 185 183 ip link add dev br0 type bridge mcast_snooping 0 184 + ip link add name dummy1 up type dummy 186 185 187 186 ip link add name vxlan0 up type vxlan id 10 nolearning noudpcsum \ 188 - ttl 20 tos inherit local 198.51.100.1 dstport 4789 dev $swp2 187 + ttl 20 tos inherit local 198.51.100.1 dstport 4789 dev dummy1 189 188 190 189 sanitization_single_dev_test_fail 191 190 192 191 ip link del dev vxlan0 192 + ip link del dev dummy1 193 193 ip link del dev br0 194 194 195 195 log_test "vxlan device with local interface"
+51 -2
tools/testing/selftests/ptp/testptp.c
··· 44 44 } 45 45 #endif 46 46 47 + static void show_flag_test(int rq_index, unsigned int flags, int err) 48 + { 49 + printf("PTP_EXTTS_REQUEST%c flags 0x%08x : (%d) %s\n", 50 + rq_index ? '1' + rq_index : ' ', 51 + flags, err, strerror(errno)); 52 + /* sigh, uClibc ... */ 53 + errno = 0; 54 + } 55 + 56 + static void do_flag_test(int fd, unsigned int index) 57 + { 58 + struct ptp_extts_request extts_request; 59 + unsigned long request[2] = { 60 + PTP_EXTTS_REQUEST, 61 + PTP_EXTTS_REQUEST2, 62 + }; 63 + unsigned int enable_flags[5] = { 64 + PTP_ENABLE_FEATURE, 65 + PTP_ENABLE_FEATURE | PTP_RISING_EDGE, 66 + PTP_ENABLE_FEATURE | PTP_FALLING_EDGE, 67 + PTP_ENABLE_FEATURE | PTP_RISING_EDGE | PTP_FALLING_EDGE, 68 + PTP_ENABLE_FEATURE | (PTP_EXTTS_VALID_FLAGS + 1), 69 + }; 70 + int err, i, j; 71 + 72 + memset(&extts_request, 0, sizeof(extts_request)); 73 + extts_request.index = index; 74 + 75 + for (i = 0; i < 2; i++) { 76 + for (j = 0; j < 5; j++) { 77 + extts_request.flags = enable_flags[j]; 78 + err = ioctl(fd, request[i], &extts_request); 79 + show_flag_test(i, extts_request.flags, err); 80 + 81 + extts_request.flags = 0; 82 + err = ioctl(fd, request[i], &extts_request); 83 + } 84 + } 85 + } 86 + 47 87 static clockid_t get_clockid(int fd) 48 88 { 49 89 #define CLOCKFD 3 ··· 136 96 " -s set the ptp clock time from the system time\n" 137 97 " -S set the system time from the ptp clock time\n" 138 98 " -t val shift the ptp clock time by 'val' seconds\n" 139 - " -T val set the ptp clock time to 'val' seconds\n", 99 + " -T val set the ptp clock time to 'val' seconds\n" 100 + " -z test combinations of rising/falling external time stamp flags\n", 140 101 progname); 141 102 } 142 103 ··· 163 122 int adjtime = 0; 164 123 int capabilities = 0; 165 124 int extts = 0; 125 + int flagtest = 0; 166 126 int gettime = 0; 167 127 int index = 0; 168 128 int list_pins = 0; ··· 180 138 181 139 progname = strrchr(argv[0], '/'); 182 140 progname = progname ? 1+progname : argv[0]; 183 - while (EOF != (c = getopt(argc, argv, "cd:e:f:ghi:k:lL:p:P:sSt:T:v"))) { 141 + while (EOF != (c = getopt(argc, argv, "cd:e:f:ghi:k:lL:p:P:sSt:T:z"))) { 184 142 switch (c) { 185 143 case 'c': 186 144 capabilities = 1; ··· 232 190 case 'T': 233 191 settime = 3; 234 192 seconds = atoi(optarg); 193 + break; 194 + case 'z': 195 + flagtest = 1; 235 196 break; 236 197 case 'h': 237 198 usage(progname); ··· 365 320 if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) { 366 321 perror("PTP_EXTTS_REQUEST"); 367 322 } 323 + } 324 + 325 + if (flagtest) { 326 + do_flag_test(fd, index); 368 327 } 369 328 370 329 if (list_pins) {