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

+1

Documentation/devicetree/bindings/net/renesas,ravb.txt

··· 21 21 - "renesas,etheravb-r8a774a1" for the R8A774A1 SoC. 22 22 - "renesas,etheravb-r8a774b1" for the R8A774B1 SoC. 23 23 - "renesas,etheravb-r8a774c0" for the R8A774C0 SoC. 24 + - "renesas,etheravb-r8a774e1" for the R8A774E1 SoC. 24 25 - "renesas,etheravb-r8a7795" for the R8A7795 SoC. 25 26 - "renesas,etheravb-r8a7796" for the R8A77960 SoC. 26 27 - "renesas,etheravb-r8a77961" for the R8A77961 SoC.

+5 -2

MAINTAINERS

··· 8752 8752 F: include/uapi/drm/i915_drm.h 8753 8753 8754 8754 INTEL ETHERNET DRIVERS 8755 - M: Jeff Kirsher <jeffrey.t.kirsher@intel.com> 8755 + M: Jesse Brandeburg <jesse.brandeburg@intel.com> 8756 + M: Tony Nguyen <anthony.l.nguyen@intel.com> 8756 8757 L: intel-wired-lan@lists.osuosl.org (moderated for non-subscribers) 8757 8758 S: Supported 8758 8759 W: http://www.intel.com/support/feedback.htm ··· 12078 12077 M: Andrew Lunn <andrew@lunn.ch> 12079 12078 M: Vivien Didelot <vivien.didelot@gmail.com> 12080 12079 M: Florian Fainelli <f.fainelli@gmail.com> 12080 + M: Vladimir Oltean <olteanv@gmail.com> 12081 12081 S: Maintained 12082 12082 F: Documentation/devicetree/bindings/net/dsa/ 12083 12083 F: drivers/net/dsa/ ··· 18284 18282 F: include/linux/vga_switcheroo.h 18285 18283 18286 18284 VIA RHINE NETWORK DRIVER 18287 - S: Orphan 18285 + S: Maintained 18286 + M: Kevin Brace <kevinbrace@bracecomputerlab.com> 18288 18287 F: drivers/net/ethernet/via/via-rhine.c 18289 18288 18290 18289 VIA SD/MMC CARD CONTROLLER DRIVER

-1

arch/powerpc/net/bpf_jit_comp.c

··· 475 475 case BPF_JMP | BPF_JSET | BPF_K: 476 476 case BPF_JMP | BPF_JSET | BPF_X: 477 477 true_cond = COND_NE; 478 - fallthrough; 479 478 cond_branch: 480 479 /* same targets, can avoid doing the test :) */ 481 480 if (filter[i].jt == filter[i].jf) {

+1 -1

drivers/block/drbd/drbd_main.c

··· 1553 1553 * put_page(); and would cause either a VM_BUG directly, or 1554 1554 * __page_cache_release a page that would actually still be referenced 1555 1555 * by someone, leading to some obscure delayed Oops somewhere else. */ 1556 - if (drbd_disable_sendpage || (page_count(page) < 1) || PageSlab(page)) 1556 + if (drbd_disable_sendpage || !sendpage_ok(page)) 1557 1557 return _drbd_no_send_page(peer_device, page, offset, size, msg_flags); 1558 1558 1559 1559 msg_flags |= MSG_NOSIGNAL;

+7 -3

drivers/infiniband/core/cache.c

··· 1320 1320 } 1321 1321 EXPORT_SYMBOL(rdma_read_gid_attr_ndev_rcu); 1322 1322 1323 - static int get_lower_dev_vlan(struct net_device *lower_dev, void *data) 1323 + static int get_lower_dev_vlan(struct net_device *lower_dev, 1324 + struct netdev_nested_priv *priv) 1324 1325 { 1325 - u16 *vlan_id = data; 1326 + u16 *vlan_id = (u16 *)priv->data; 1326 1327 1327 1328 if (is_vlan_dev(lower_dev)) 1328 1329 *vlan_id = vlan_dev_vlan_id(lower_dev); ··· 1349 1348 int rdma_read_gid_l2_fields(const struct ib_gid_attr *attr, 1350 1349 u16 *vlan_id, u8 *smac) 1351 1350 { 1351 + struct netdev_nested_priv priv = { 1352 + .data = (void *)vlan_id, 1353 + }; 1352 1354 struct net_device *ndev; 1353 1355 1354 1356 rcu_read_lock(); ··· 1372 1368 * the lower vlan device for this gid entry. 1373 1369 */ 1374 1370 netdev_walk_all_lower_dev_rcu(attr->ndev, 1375 - get_lower_dev_vlan, vlan_id); 1371 + get_lower_dev_vlan, &priv); 1376 1372 } 1377 1373 } 1378 1374 rcu_read_unlock();

+6 -3

drivers/infiniband/core/cma.c

··· 2865 2865 bool found; 2866 2866 }; 2867 2867 2868 - static int get_lower_vlan_dev_tc(struct net_device *dev, void *data) 2868 + static int get_lower_vlan_dev_tc(struct net_device *dev, 2869 + struct netdev_nested_priv *priv) 2869 2870 { 2870 - struct iboe_prio_tc_map *map = data; 2871 + struct iboe_prio_tc_map *map = (struct iboe_prio_tc_map *)priv->data; 2871 2872 2872 2873 if (is_vlan_dev(dev)) 2873 2874 map->output_tc = get_vlan_ndev_tc(dev, map->input_prio); ··· 2887 2886 { 2888 2887 struct iboe_prio_tc_map prio_tc_map = {}; 2889 2888 int prio = rt_tos2priority(tos); 2889 + struct netdev_nested_priv priv; 2890 2890 2891 2891 /* If VLAN device, get it directly from the VLAN netdev */ 2892 2892 if (is_vlan_dev(ndev)) 2893 2893 return get_vlan_ndev_tc(ndev, prio); 2894 2894 2895 2895 prio_tc_map.input_prio = prio; 2896 + priv.data = (void *)&prio_tc_map; 2896 2897 rcu_read_lock(); 2897 2898 netdev_walk_all_lower_dev_rcu(ndev, 2898 2899 get_lower_vlan_dev_tc, 2899 - &prio_tc_map); 2900 + &priv); 2900 2901 rcu_read_unlock(); 2901 2902 /* If map is found from lower device, use it; Otherwise 2902 2903 * continue with the current netdevice to get priority to tc map.

+6 -3

drivers/infiniband/core/roce_gid_mgmt.c

··· 531 531 struct net_device *upper; 532 532 }; 533 533 534 - static int netdev_upper_walk(struct net_device *upper, void *data) 534 + static int netdev_upper_walk(struct net_device *upper, 535 + struct netdev_nested_priv *priv) 535 536 { 536 537 struct upper_list *entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 537 - struct list_head *upper_list = data; 538 + struct list_head *upper_list = (struct list_head *)priv->data; 538 539 539 540 if (!entry) 540 541 return 0; ··· 554 553 struct net_device *ndev)) 555 554 { 556 555 struct net_device *ndev = cookie; 556 + struct netdev_nested_priv priv; 557 557 struct upper_list *upper_iter; 558 558 struct upper_list *upper_temp; 559 559 LIST_HEAD(upper_list); 560 560 561 + priv.data = &upper_list; 561 562 rcu_read_lock(); 562 - netdev_walk_all_upper_dev_rcu(ndev, netdev_upper_walk, &upper_list); 563 + netdev_walk_all_upper_dev_rcu(ndev, netdev_upper_walk, &priv); 563 564 rcu_read_unlock(); 564 565 565 566 handle_netdev(ib_dev, port, ndev);

+6 -3

drivers/infiniband/ulp/ipoib/ipoib_main.c

··· 342 342 struct net_device *result; 343 343 }; 344 344 345 - static int ipoib_upper_walk(struct net_device *upper, void *_data) 345 + static int ipoib_upper_walk(struct net_device *upper, 346 + struct netdev_nested_priv *priv) 346 347 { 347 - struct ipoib_walk_data *data = _data; 348 + struct ipoib_walk_data *data = (struct ipoib_walk_data *)priv->data; 348 349 int ret = 0; 349 350 350 351 if (ipoib_is_dev_match_addr_rcu(data->addr, upper)) { ··· 369 368 static struct net_device *ipoib_get_net_dev_match_addr( 370 369 const struct sockaddr *addr, struct net_device *dev) 371 370 { 371 + struct netdev_nested_priv priv; 372 372 struct ipoib_walk_data data = { 373 373 .addr = addr, 374 374 }; 375 375 376 + priv.data = (void *)&data; 376 377 rcu_read_lock(); 377 378 if (ipoib_is_dev_match_addr_rcu(addr, dev)) { 378 379 dev_hold(dev); ··· 382 379 goto out; 383 380 } 384 381 385 - netdev_walk_all_upper_dev_rcu(dev, ipoib_upper_walk, &data); 382 + netdev_walk_all_upper_dev_rcu(dev, ipoib_upper_walk, &priv); 386 383 out: 387 384 rcu_read_unlock(); 388 385 return data.result;

+6 -3

drivers/net/bonding/bond_alb.c

··· 942 942 bool strict_match; 943 943 }; 944 944 945 - static int alb_upper_dev_walk(struct net_device *upper, void *_data) 945 + static int alb_upper_dev_walk(struct net_device *upper, 946 + struct netdev_nested_priv *priv) 946 947 { 947 - struct alb_walk_data *data = _data; 948 + struct alb_walk_data *data = (struct alb_walk_data *)priv->data; 948 949 bool strict_match = data->strict_match; 949 950 struct bonding *bond = data->bond; 950 951 struct slave *slave = data->slave; ··· 984 983 bool strict_match) 985 984 { 986 985 struct bonding *bond = bond_get_bond_by_slave(slave); 986 + struct netdev_nested_priv priv; 987 987 struct alb_walk_data data = { 988 988 .strict_match = strict_match, 989 989 .mac_addr = mac_addr, ··· 992 990 .bond = bond, 993 991 }; 994 992 993 + priv.data = (void *)&data; 995 994 /* send untagged */ 996 995 alb_send_lp_vid(slave, mac_addr, 0, 0); 997 996 ··· 1000 997 * for that device. 1001 998 */ 1002 999 rcu_read_lock(); 1003 - netdev_walk_all_upper_dev_rcu(bond->dev, alb_upper_dev_walk, &data); 1000 + netdev_walk_all_upper_dev_rcu(bond->dev, alb_upper_dev_walk, &priv); 1004 1001 rcu_read_unlock(); 1005 1002 } 1006 1003

+8 -3

drivers/net/bonding/bond_main.c

··· 1315 1315 1316 1316 bond_dev->type = slave_dev->type; 1317 1317 bond_dev->hard_header_len = slave_dev->hard_header_len; 1318 + bond_dev->needed_headroom = slave_dev->needed_headroom; 1318 1319 bond_dev->addr_len = slave_dev->addr_len; 1319 1320 1320 1321 memcpy(bond_dev->broadcast, slave_dev->broadcast, ··· 2511 2510 } 2512 2511 } 2513 2512 2514 - static int bond_upper_dev_walk(struct net_device *upper, void *data) 2513 + static int bond_upper_dev_walk(struct net_device *upper, 2514 + struct netdev_nested_priv *priv) 2515 2515 { 2516 - __be32 ip = *((__be32 *)data); 2516 + __be32 ip = *(__be32 *)priv->data; 2517 2517 2518 2518 return ip == bond_confirm_addr(upper, 0, ip); 2519 2519 } 2520 2520 2521 2521 static bool bond_has_this_ip(struct bonding *bond, __be32 ip) 2522 2522 { 2523 + struct netdev_nested_priv priv = { 2524 + .data = (void *)&ip, 2525 + }; 2523 2526 bool ret = false; 2524 2527 2525 2528 if (ip == bond_confirm_addr(bond->dev, 0, ip)) 2526 2529 return true; 2527 2530 2528 2531 rcu_read_lock(); 2529 - if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &ip)) 2532 + if (netdev_walk_all_upper_dev_rcu(bond->dev, bond_upper_dev_walk, &priv)) 2530 2533 ret = true; 2531 2534 rcu_read_unlock(); 2532 2535

+12 -8

drivers/net/dsa/microchip/ksz_common.c

··· 387 387 int ksz_switch_register(struct ksz_device *dev, 388 388 const struct ksz_dev_ops *ops) 389 389 { 390 + struct device_node *port, *ports; 390 391 phy_interface_t interface; 391 - struct device_node *port; 392 392 unsigned int port_num; 393 393 int ret; 394 394 ··· 429 429 ret = of_get_phy_mode(dev->dev->of_node, &interface); 430 430 if (ret == 0) 431 431 dev->compat_interface = interface; 432 - for_each_available_child_of_node(dev->dev->of_node, port) { 433 - if (of_property_read_u32(port, "reg", &port_num)) 434 - continue; 435 - if (port_num >= dev->port_cnt) 436 - return -EINVAL; 437 - of_get_phy_mode(port, &dev->ports[port_num].interface); 438 - } 432 + ports = of_get_child_by_name(dev->dev->of_node, "ports"); 433 + if (ports) 434 + for_each_available_child_of_node(ports, port) { 435 + if (of_property_read_u32(port, "reg", 436 + &port_num)) 437 + continue; 438 + if (port_num >= dev->port_cnt) 439 + return -EINVAL; 440 + of_get_phy_mode(port, 441 + &dev->ports[port_num].interface); 442 + } 439 443 dev->synclko_125 = of_property_read_bool(dev->dev->of_node, 440 444 "microchip,synclko-125"); 441 445 }

+27 -7

drivers/net/dsa/ocelot/felix_vsc9959.c

··· 685 685 [VCAP_IS2_ACT_POLICE_ENA] = { 9, 1}, 686 686 [VCAP_IS2_ACT_POLICE_IDX] = { 10, 9}, 687 687 [VCAP_IS2_ACT_POLICE_VCAP_ONLY] = { 19, 1}, 688 - [VCAP_IS2_ACT_PORT_MASK] = { 20, 11}, 689 - [VCAP_IS2_ACT_REW_OP] = { 31, 9}, 690 - [VCAP_IS2_ACT_SMAC_REPLACE_ENA] = { 40, 1}, 691 - [VCAP_IS2_ACT_RSV] = { 41, 2}, 692 - [VCAP_IS2_ACT_ACL_ID] = { 43, 6}, 693 - [VCAP_IS2_ACT_HIT_CNT] = { 49, 32}, 688 + [VCAP_IS2_ACT_PORT_MASK] = { 20, 6}, 689 + [VCAP_IS2_ACT_REW_OP] = { 26, 9}, 690 + [VCAP_IS2_ACT_SMAC_REPLACE_ENA] = { 35, 1}, 691 + [VCAP_IS2_ACT_RSV] = { 36, 2}, 692 + [VCAP_IS2_ACT_ACL_ID] = { 38, 6}, 693 + [VCAP_IS2_ACT_HIT_CNT] = { 44, 32}, 694 694 }; 695 695 696 696 static const struct vcap_props vsc9959_vcap_props[] = { ··· 1284 1284 static void vsc9959_sched_speed_set(struct ocelot *ocelot, int port, 1285 1285 u32 speed) 1286 1286 { 1287 + u8 tas_speed; 1288 + 1289 + switch (speed) { 1290 + case SPEED_10: 1291 + tas_speed = OCELOT_SPEED_10; 1292 + break; 1293 + case SPEED_100: 1294 + tas_speed = OCELOT_SPEED_100; 1295 + break; 1296 + case SPEED_1000: 1297 + tas_speed = OCELOT_SPEED_1000; 1298 + break; 1299 + case SPEED_2500: 1300 + tas_speed = OCELOT_SPEED_2500; 1301 + break; 1302 + default: 1303 + tas_speed = OCELOT_SPEED_1000; 1304 + break; 1305 + } 1306 + 1287 1307 ocelot_rmw_rix(ocelot, 1288 - QSYS_TAG_CONFIG_LINK_SPEED(speed), 1308 + QSYS_TAG_CONFIG_LINK_SPEED(tas_speed), 1289 1309 QSYS_TAG_CONFIG_LINK_SPEED_M, 1290 1310 QSYS_TAG_CONFIG, port); 1291 1311 }

+1 -1

drivers/net/dsa/ocelot/seville_vsc9953.c

··· 706 706 .action_type_width = 1, 707 707 .action_table = { 708 708 [IS2_ACTION_TYPE_NORMAL] = { 709 - .width = 44, 709 + .width = 50, /* HIT_CNT not included */ 710 710 .count = 2 711 711 }, 712 712 [IS2_ACTION_TYPE_SMAC_SIP] = {

+1 -1

drivers/net/ethernet/3com/typhoon.h

··· 33 33 u32 lastWrite; 34 34 }; 35 35 36 - /* The Typoon transmit ring -- same as a basic ring, plus: 36 + /* The Typhoon transmit ring -- same as a basic ring, plus: 37 37 * lastRead: where we're at in regard to cleaning up the ring 38 38 * writeRegister: register to use for writing (different for Hi & Lo rings) 39 39 */

+1 -1

drivers/net/ethernet/aquantia/atlantic/Makefile

··· 8 8 9 9 obj-$(CONFIG_AQTION) += atlantic.o 10 10 11 - ccflags-y += -I$(src) 11 + ccflags-y += -I$(srctree)/$(src) 12 12 13 13 atlantic-objs := aq_main.o \ 14 14 aq_nic.o \

+8 -8

drivers/net/ethernet/broadcom/bnx2x/bnx2x_reg.h

··· 284 284 #define CCM_REG_GR_ARB_TYPE 0xd015c 285 285 /* [RW 2] Load (FIC0) channel group priority. The lowest priority is 0; the 286 286 highest priority is 3. It is supposed; that the Store channel priority is 287 - the compliment to 4 of the rest priorities - Aggregation channel; Load 287 + the complement to 4 of the rest priorities - Aggregation channel; Load 288 288 (FIC0) channel and Load (FIC1). */ 289 289 #define CCM_REG_GR_LD0_PR 0xd0164 290 290 /* [RW 2] Load (FIC1) channel group priority. The lowest priority is 0; the 291 291 highest priority is 3. It is supposed; that the Store channel priority is 292 - the compliment to 4 of the rest priorities - Aggregation channel; Load 292 + the complement to 4 of the rest priorities - Aggregation channel; Load 293 293 (FIC0) channel and Load (FIC1). */ 294 294 #define CCM_REG_GR_LD1_PR 0xd0168 295 295 /* [RW 2] General flags index. */ ··· 4489 4489 #define TCM_REG_GR_ARB_TYPE 0x50114 4490 4490 /* [RW 2] Load (FIC0) channel group priority. The lowest priority is 0; the 4491 4491 highest priority is 3. It is supposed that the Store channel is the 4492 - compliment of the other 3 groups. */ 4492 + complement of the other 3 groups. */ 4493 4493 #define TCM_REG_GR_LD0_PR 0x5011c 4494 4494 /* [RW 2] Load (FIC1) channel group priority. The lowest priority is 0; the 4495 4495 highest priority is 3. It is supposed that the Store channel is the 4496 - compliment of the other 3 groups. */ 4496 + complement of the other 3 groups. */ 4497 4497 #define TCM_REG_GR_LD1_PR 0x50120 4498 4498 /* [RW 4] The number of double REG-pairs; loaded from the STORM context and 4499 4499 sent to STORM; for a specific connection type. The double REG-pairs are ··· 5020 5020 #define UCM_REG_GR_ARB_TYPE 0xe0144 5021 5021 /* [RW 2] Load (FIC0) channel group priority. The lowest priority is 0; the 5022 5022 highest priority is 3. It is supposed that the Store channel group is 5023 - compliment to the others. */ 5023 + complement to the others. */ 5024 5024 #define UCM_REG_GR_LD0_PR 0xe014c 5025 5025 /* [RW 2] Load (FIC1) channel group priority. The lowest priority is 0; the 5026 5026 highest priority is 3. It is supposed that the Store channel group is 5027 - compliment to the others. */ 5027 + complement to the others. */ 5028 5028 #define UCM_REG_GR_LD1_PR 0xe0150 5029 5029 /* [RW 2] The queue index for invalidate counter flag decision. */ 5030 5030 #define UCM_REG_INV_CFLG_Q 0xe00e4 ··· 5523 5523 #define XCM_REG_GR_ARB_TYPE 0x2020c 5524 5524 /* [RW 2] Load (FIC0) channel group priority. The lowest priority is 0; the 5525 5525 highest priority is 3. It is supposed that the Channel group is the 5526 - compliment of the other 3 groups. */ 5526 + complement of the other 3 groups. */ 5527 5527 #define XCM_REG_GR_LD0_PR 0x20214 5528 5528 /* [RW 2] Load (FIC1) channel group priority. The lowest priority is 0; the 5529 5529 highest priority is 3. It is supposed that the Channel group is the 5530 - compliment of the other 3 groups. */ 5530 + complement of the other 3 groups. */ 5531 5531 #define XCM_REG_GR_LD1_PR 0x20218 5532 5532 /* [RW 1] Input nig0 Interface enable. If 0 - the valid input is 5533 5533 disregarded; acknowledge output is deasserted; all other signals are

+4 -2

drivers/net/ethernet/cavium/octeon/octeon_mgmt.c

··· 1219 1219 */ 1220 1220 if (netdev->phydev) { 1221 1221 netif_carrier_off(netdev); 1222 - phy_start_aneg(netdev->phydev); 1222 + phy_start(netdev->phydev); 1223 1223 } 1224 1224 1225 1225 netif_wake_queue(netdev); ··· 1247 1247 napi_disable(&p->napi); 1248 1248 netif_stop_queue(netdev); 1249 1249 1250 - if (netdev->phydev) 1250 + if (netdev->phydev) { 1251 + phy_stop(netdev->phydev); 1251 1252 phy_disconnect(netdev->phydev); 1253 + } 1252 1254 1253 1255 netif_carrier_off(netdev); 1254 1256

+3 -1

drivers/net/ethernet/freescale/dpaa2/dpni-cmd.h

··· 11 11 #define DPNI_VER_MAJOR 7 12 12 #define DPNI_VER_MINOR 0 13 13 #define DPNI_CMD_BASE_VERSION 1 14 + #define DPNI_CMD_2ND_VERSION 2 14 15 #define DPNI_CMD_ID_OFFSET 4 15 16 16 17 #define DPNI_CMD(id) (((id) << DPNI_CMD_ID_OFFSET) | DPNI_CMD_BASE_VERSION) 18 + #define DPNI_CMD_V2(id) (((id) << DPNI_CMD_ID_OFFSET) | DPNI_CMD_2ND_VERSION) 17 19 18 20 #define DPNI_CMDID_OPEN DPNI_CMD(0x801) 19 21 #define DPNI_CMDID_CLOSE DPNI_CMD(0x800) ··· 47 45 #define DPNI_CMDID_SET_MAX_FRAME_LENGTH DPNI_CMD(0x216) 48 46 #define DPNI_CMDID_GET_MAX_FRAME_LENGTH DPNI_CMD(0x217) 49 47 #define DPNI_CMDID_SET_LINK_CFG DPNI_CMD(0x21A) 50 - #define DPNI_CMDID_SET_TX_SHAPING DPNI_CMD(0x21B) 48 + #define DPNI_CMDID_SET_TX_SHAPING DPNI_CMD_V2(0x21B) 51 49 52 50 #define DPNI_CMDID_SET_MCAST_PROMISC DPNI_CMD(0x220) 53 51 #define DPNI_CMDID_GET_MCAST_PROMISC DPNI_CMD(0x221)

+1 -1

drivers/net/ethernet/freescale/xgmac_mdio.c

··· 229 229 /* Return all Fs if nothing was there */ 230 230 if ((xgmac_read32(&regs->mdio_stat, endian) & MDIO_STAT_RD_ER) && 231 231 !priv->has_a011043) { 232 - dev_err(&bus->dev, 232 + dev_dbg(&bus->dev, 233 233 "Error while reading PHY%d reg at %d.%hhu\n", 234 234 phy_id, dev_addr, regnum); 235 235 return 0xffff;

+1

drivers/net/ethernet/huawei/hinic/Kconfig

··· 6 6 config HINIC 7 7 tristate "Huawei Intelligent PCIE Network Interface Card" 8 8 depends on (PCI_MSI && (X86 || ARM64)) 9 + select NET_DEVLINK 9 10 help 10 11 This driver supports HiNIC PCIE Ethernet cards. 11 12 To compile this driver as part of the kernel, choose Y here.

+3 -3

drivers/net/ethernet/huawei/hinic/hinic_port.c

··· 58 58 sizeof(port_mac_cmd), 59 59 &port_mac_cmd, &out_size); 60 60 if (err || out_size != sizeof(port_mac_cmd) || 61 - (port_mac_cmd.status && 62 - port_mac_cmd.status != HINIC_PF_SET_VF_ALREADY && 63 - port_mac_cmd.status != HINIC_MGMT_STATUS_EXIST)) { 61 + (port_mac_cmd.status && 62 + (port_mac_cmd.status != HINIC_PF_SET_VF_ALREADY || !HINIC_IS_VF(hwif)) && 63 + port_mac_cmd.status != HINIC_MGMT_STATUS_EXIST)) { 64 64 dev_err(&pdev->dev, "Failed to change MAC, err: %d, status: 0x%x, out size: 0x%x\n", 65 65 err, port_mac_cmd.status, out_size); 66 66 return -EFAULT;

+2 -10

drivers/net/ethernet/huawei/hinic/hinic_sriov.c

··· 38 38 err = hinic_port_msg_cmd(hwdev, HINIC_PORT_CMD_SET_MAC, &mac_info, 39 39 sizeof(mac_info), &mac_info, &out_size); 40 40 if (err || out_size != sizeof(mac_info) || 41 - (mac_info.status && mac_info.status != HINIC_PF_SET_VF_ALREADY && 42 - mac_info.status != HINIC_MGMT_STATUS_EXIST)) { 41 + (mac_info.status && mac_info.status != HINIC_MGMT_STATUS_EXIST)) { 43 42 dev_err(&hwdev->func_to_io.hwif->pdev->dev, "Failed to set MAC, err: %d, status: 0x%x, out size: 0x%x\n", 44 43 err, mac_info.status, out_size); 45 44 return -EIO; ··· 502 503 503 504 static int hinic_check_mac_info(u8 status, u16 vlan_id) 504 505 { 505 - if ((status && status != HINIC_MGMT_STATUS_EXIST && 506 - status != HINIC_PF_SET_VF_ALREADY) || 506 + if ((status && status != HINIC_MGMT_STATUS_EXIST) || 507 507 (vlan_id & CHECK_IPSU_15BIT && 508 508 status == HINIC_MGMT_STATUS_EXIST)) 509 509 return -EINVAL; ··· 542 544 "Failed to update MAC, err: %d, status: 0x%x, out size: 0x%x\n", 543 545 err, mac_info.status, out_size); 544 546 return -EINVAL; 545 - } 546 - 547 - if (mac_info.status == HINIC_PF_SET_VF_ALREADY) { 548 - dev_warn(&hwdev->hwif->pdev->dev, 549 - "PF has already set VF MAC. Ignore update operation\n"); 550 - return HINIC_PF_SET_VF_ALREADY; 551 547 } 552 548 553 549 if (mac_info.status == HINIC_MGMT_STATUS_EXIST)

+2 -2

drivers/net/ethernet/intel/iavf/iavf_main.c

··· 3806 3806 static int __maybe_unused iavf_resume(struct device *dev_d) 3807 3807 { 3808 3808 struct pci_dev *pdev = to_pci_dev(dev_d); 3809 - struct iavf_adapter *adapter = pci_get_drvdata(pdev); 3810 - struct net_device *netdev = adapter->netdev; 3809 + struct net_device *netdev = pci_get_drvdata(pdev); 3810 + struct iavf_adapter *adapter = netdev_priv(netdev); 3811 3811 u32 err; 3812 3812 3813 3813 pci_set_master(pdev);

+27 -22

drivers/net/ethernet/intel/ice/ice_common.c

··· 2288 2288 { 2289 2289 struct ice_hw_func_caps *func_caps = &hw->func_caps; 2290 2290 struct ice_hw_dev_caps *dev_caps = &hw->dev_caps; 2291 - u32 valid_func, rxq_first_id, txq_first_id; 2292 - u32 msix_vector_first_id, max_mtu; 2291 + struct ice_hw_common_caps cached_caps; 2293 2292 u32 num_funcs; 2294 2293 2295 2294 /* cache some func_caps values that should be restored after memset */ 2296 - valid_func = func_caps->common_cap.valid_functions; 2297 - txq_first_id = func_caps->common_cap.txq_first_id; 2298 - rxq_first_id = func_caps->common_cap.rxq_first_id; 2299 - msix_vector_first_id = func_caps->common_cap.msix_vector_first_id; 2300 - max_mtu = func_caps->common_cap.max_mtu; 2295 + cached_caps = func_caps->common_cap; 2301 2296 2302 2297 /* unset func capabilities */ 2303 2298 memset(func_caps, 0, sizeof(*func_caps)); 2304 2299 2300 + #define ICE_RESTORE_FUNC_CAP(name) \ 2301 + func_caps->common_cap.name = cached_caps.name 2302 + 2305 2303 /* restore cached values */ 2306 - func_caps->common_cap.valid_functions = valid_func; 2307 - func_caps->common_cap.txq_first_id = txq_first_id; 2308 - func_caps->common_cap.rxq_first_id = rxq_first_id; 2309 - func_caps->common_cap.msix_vector_first_id = msix_vector_first_id; 2310 - func_caps->common_cap.max_mtu = max_mtu; 2304 + ICE_RESTORE_FUNC_CAP(valid_functions); 2305 + ICE_RESTORE_FUNC_CAP(txq_first_id); 2306 + ICE_RESTORE_FUNC_CAP(rxq_first_id); 2307 + ICE_RESTORE_FUNC_CAP(msix_vector_first_id); 2308 + ICE_RESTORE_FUNC_CAP(max_mtu); 2309 + ICE_RESTORE_FUNC_CAP(nvm_unified_update); 2310 + ICE_RESTORE_FUNC_CAP(nvm_update_pending_nvm); 2311 + ICE_RESTORE_FUNC_CAP(nvm_update_pending_orom); 2312 + ICE_RESTORE_FUNC_CAP(nvm_update_pending_netlist); 2311 2313 2312 2314 /* one Tx and one Rx queue in safe mode */ 2313 2315 func_caps->common_cap.num_rxq = 1; ··· 2320 2318 func_caps->guar_num_vsi = 1; 2321 2319 2322 2320 /* cache some dev_caps values that should be restored after memset */ 2323 - valid_func = dev_caps->common_cap.valid_functions; 2324 - txq_first_id = dev_caps->common_cap.txq_first_id; 2325 - rxq_first_id = dev_caps->common_cap.rxq_first_id; 2326 - msix_vector_first_id = dev_caps->common_cap.msix_vector_first_id; 2327 - max_mtu = dev_caps->common_cap.max_mtu; 2321 + cached_caps = dev_caps->common_cap; 2328 2322 num_funcs = dev_caps->num_funcs; 2329 2323 2330 2324 /* unset dev capabilities */ 2331 2325 memset(dev_caps, 0, sizeof(*dev_caps)); 2332 2326 2327 + #define ICE_RESTORE_DEV_CAP(name) \ 2328 + dev_caps->common_cap.name = cached_caps.name 2329 + 2333 2330 /* restore cached values */ 2334 - dev_caps->common_cap.valid_functions = valid_func; 2335 - dev_caps->common_cap.txq_first_id = txq_first_id; 2336 - dev_caps->common_cap.rxq_first_id = rxq_first_id; 2337 - dev_caps->common_cap.msix_vector_first_id = msix_vector_first_id; 2338 - dev_caps->common_cap.max_mtu = max_mtu; 2331 + ICE_RESTORE_DEV_CAP(valid_functions); 2332 + ICE_RESTORE_DEV_CAP(txq_first_id); 2333 + ICE_RESTORE_DEV_CAP(rxq_first_id); 2334 + ICE_RESTORE_DEV_CAP(msix_vector_first_id); 2335 + ICE_RESTORE_DEV_CAP(max_mtu); 2336 + ICE_RESTORE_DEV_CAP(nvm_unified_update); 2337 + ICE_RESTORE_DEV_CAP(nvm_update_pending_nvm); 2338 + ICE_RESTORE_DEV_CAP(nvm_update_pending_orom); 2339 + ICE_RESTORE_DEV_CAP(nvm_update_pending_netlist); 2339 2340 dev_caps->num_funcs = num_funcs; 2340 2341 2341 2342 /* one Tx and one Rx queue per function in safe mode */

+8 -2

drivers/net/ethernet/intel/ice/ice_fw_update.c

··· 289 289 return -EIO; 290 290 } 291 291 292 - err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write, HZ, &event); 292 + /* In most cases, firmware reports a write completion within a few 293 + * milliseconds. However, it has been observed that a completion might 294 + * take more than a second to complete in some cases. The timeout here 295 + * is conservative and is intended to prevent failure to update when 296 + * firmware is slow to respond. 297 + */ 298 + err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write, 15 * HZ, &event); 293 299 if (err) { 294 300 dev_err(dev, "Timed out waiting for firmware write completion for module 0x%02x, err %d\n", 295 301 module, err); ··· 519 513 return -EIO; 520 514 } 521 515 522 - err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write_activate, HZ, 516 + err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write_activate, 30 * HZ, 523 517 &event); 524 518 if (err) { 525 519 dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",

+16 -4

drivers/net/ethernet/intel/ice/ice_lib.c

··· 246 246 * ice_vsi_delete - delete a VSI from the switch 247 247 * @vsi: pointer to VSI being removed 248 248 */ 249 - void ice_vsi_delete(struct ice_vsi *vsi) 249 + static void ice_vsi_delete(struct ice_vsi *vsi) 250 250 { 251 251 struct ice_pf *pf = vsi->back; 252 252 struct ice_vsi_ctx *ctxt; ··· 313 313 * 314 314 * Returns 0 on success, negative on failure 315 315 */ 316 - int ice_vsi_clear(struct ice_vsi *vsi) 316 + static int ice_vsi_clear(struct ice_vsi *vsi) 317 317 { 318 318 struct ice_pf *pf = NULL; 319 319 struct device *dev; ··· 563 563 * ice_vsi_put_qs - Release queues from VSI to PF 564 564 * @vsi: the VSI that is going to release queues 565 565 */ 566 - void ice_vsi_put_qs(struct ice_vsi *vsi) 566 + static void ice_vsi_put_qs(struct ice_vsi *vsi) 567 567 { 568 568 struct ice_pf *pf = vsi->back; 569 569 int i; ··· 1195 1195 static void ice_vsi_clear_rings(struct ice_vsi *vsi) 1196 1196 { 1197 1197 int i; 1198 + 1199 + /* Avoid stale references by clearing map from vector to ring */ 1200 + if (vsi->q_vectors) { 1201 + ice_for_each_q_vector(vsi, i) { 1202 + struct ice_q_vector *q_vector = vsi->q_vectors[i]; 1203 + 1204 + if (q_vector) { 1205 + q_vector->tx.ring = NULL; 1206 + q_vector->rx.ring = NULL; 1207 + } 1208 + } 1209 + } 1198 1210 1199 1211 if (vsi->tx_rings) { 1200 1212 for (i = 0; i < vsi->alloc_txq; i++) { ··· 2303 2291 if (status) { 2304 2292 dev_err(dev, "VSI %d failed lan queue config, error %s\n", 2305 2293 vsi->vsi_num, ice_stat_str(status)); 2306 - goto unroll_vector_base; 2294 + goto unroll_clear_rings; 2307 2295 } 2308 2296 2309 2297 /* Add switch rule to drop all Tx Flow Control Frames, of look up

-6

drivers/net/ethernet/intel/ice/ice_lib.h

··· 45 45 46 46 void ice_cfg_sw_lldp(struct ice_vsi *vsi, bool tx, bool create); 47 47 48 - void ice_vsi_delete(struct ice_vsi *vsi); 49 - 50 - int ice_vsi_clear(struct ice_vsi *vsi); 51 - 52 48 #ifdef CONFIG_DCB 53 49 int ice_vsi_cfg_tc(struct ice_vsi *vsi, u8 ena_tc); 54 50 #endif /* CONFIG_DCB */ ··· 74 78 75 79 void 76 80 ice_write_qrxflxp_cntxt(struct ice_hw *hw, u16 pf_q, u32 rxdid, u32 prio); 77 - 78 - void ice_vsi_put_qs(struct ice_vsi *vsi); 79 81 80 82 void ice_vsi_dis_irq(struct ice_vsi *vsi); 81 83

+4 -10

drivers/net/ethernet/intel/ice/ice_main.c

··· 3169 3169 return -EBUSY; 3170 3170 3171 3171 vsi = ice_pf_vsi_setup(pf, pf->hw.port_info); 3172 - if (!vsi) { 3173 - status = -ENOMEM; 3174 - goto unroll_vsi_setup; 3175 - } 3172 + if (!vsi) 3173 + return -ENOMEM; 3176 3174 3177 3175 status = ice_cfg_netdev(vsi); 3178 3176 if (status) { ··· 3217 3219 } 3218 3220 3219 3221 unroll_vsi_setup: 3220 - if (vsi) { 3221 - ice_vsi_free_q_vectors(vsi); 3222 - ice_vsi_delete(vsi); 3223 - ice_vsi_put_qs(vsi); 3224 - ice_vsi_clear(vsi); 3225 - } 3222 + ice_vsi_release(vsi); 3226 3223 return status; 3227 3224 } 3228 3225 ··· 4515 4522 } 4516 4523 ice_clear_interrupt_scheme(pf); 4517 4524 4525 + pci_save_state(pdev); 4518 4526 pci_wake_from_d3(pdev, pf->wol_ena); 4519 4527 pci_set_power_state(pdev, PCI_D3hot); 4520 4528 return 0;

+26 -11

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

··· 5396 5396 return err; 5397 5397 } 5398 5398 5399 - static int ixgbe_macvlan_up(struct net_device *vdev, void *data) 5399 + static int ixgbe_macvlan_up(struct net_device *vdev, 5400 + struct netdev_nested_priv *priv) 5400 5401 { 5401 - struct ixgbe_adapter *adapter = data; 5402 + struct ixgbe_adapter *adapter = (struct ixgbe_adapter *)priv->data; 5402 5403 struct ixgbe_fwd_adapter *accel; 5403 5404 5404 5405 if (!netif_is_macvlan(vdev)) ··· 5416 5415 5417 5416 static void ixgbe_configure_dfwd(struct ixgbe_adapter *adapter) 5418 5417 { 5418 + struct netdev_nested_priv priv = { 5419 + .data = (void *)adapter, 5420 + }; 5421 + 5419 5422 netdev_walk_all_upper_dev_rcu(adapter->netdev, 5420 - ixgbe_macvlan_up, adapter); 5423 + ixgbe_macvlan_up, &priv); 5421 5424 } 5422 5425 5423 5426 static void ixgbe_configure(struct ixgbe_adapter *adapter) ··· 9028 9023 } 9029 9024 9030 9025 #endif /* CONFIG_IXGBE_DCB */ 9031 - static int ixgbe_reassign_macvlan_pool(struct net_device *vdev, void *data) 9026 + static int ixgbe_reassign_macvlan_pool(struct net_device *vdev, 9027 + struct netdev_nested_priv *priv) 9032 9028 { 9033 - struct ixgbe_adapter *adapter = data; 9029 + struct ixgbe_adapter *adapter = (struct ixgbe_adapter *)priv->data; 9034 9030 struct ixgbe_fwd_adapter *accel; 9035 9031 int pool; 9036 9032 ··· 9068 9062 static void ixgbe_defrag_macvlan_pools(struct net_device *dev) 9069 9063 { 9070 9064 struct ixgbe_adapter *adapter = netdev_priv(dev); 9065 + struct netdev_nested_priv priv = { 9066 + .data = (void *)adapter, 9067 + }; 9071 9068 9072 9069 /* flush any stale bits out of the fwd bitmask */ 9073 9070 bitmap_clear(adapter->fwd_bitmask, 1, 63); 9074 9071 9075 9072 /* walk through upper devices reassigning pools */ 9076 9073 netdev_walk_all_upper_dev_rcu(dev, ixgbe_reassign_macvlan_pool, 9077 - adapter); 9074 + &priv); 9078 9075 } 9079 9076 9080 9077 /** ··· 9251 9242 u8 queue; 9252 9243 }; 9253 9244 9254 - static int get_macvlan_queue(struct net_device *upper, void *_data) 9245 + static int get_macvlan_queue(struct net_device *upper, 9246 + struct netdev_nested_priv *priv) 9255 9247 { 9256 9248 if (netif_is_macvlan(upper)) { 9257 9249 struct ixgbe_fwd_adapter *vadapter = macvlan_accel_priv(upper); 9258 - struct upper_walk_data *data = _data; 9259 - struct ixgbe_adapter *adapter = data->adapter; 9260 - int ifindex = data->ifindex; 9250 + struct ixgbe_adapter *adapter; 9251 + struct upper_walk_data *data; 9252 + int ifindex; 9261 9253 9254 + data = (struct upper_walk_data *)priv->data; 9255 + ifindex = data->ifindex; 9256 + adapter = data->adapter; 9262 9257 if (vadapter && upper->ifindex == ifindex) { 9263 9258 data->queue = adapter->rx_ring[vadapter->rx_base_queue]->reg_idx; 9264 9259 data->action = data->queue; ··· 9278 9265 { 9279 9266 struct ixgbe_ring_feature *vmdq = &adapter->ring_feature[RING_F_VMDQ]; 9280 9267 unsigned int num_vfs = adapter->num_vfs, vf; 9268 + struct netdev_nested_priv priv; 9281 9269 struct upper_walk_data data; 9282 9270 struct net_device *upper; 9283 9271 ··· 9298 9284 data.ifindex = ifindex; 9299 9285 data.action = 0; 9300 9286 data.queue = 0; 9287 + priv.data = (void *)&data; 9301 9288 if (netdev_walk_all_upper_dev_rcu(adapter->netdev, 9302 - get_macvlan_queue, &data)) { 9289 + get_macvlan_queue, &priv)) { 9303 9290 *action = data.action; 9304 9291 *queue = data.queue; 9305 9292

+2

drivers/net/ethernet/lantiq_xrx200.c

··· 245 245 int pkts = 0; 246 246 int bytes = 0; 247 247 248 + netif_tx_lock(net_dev); 248 249 while (pkts < budget) { 249 250 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->tx_free]; 250 251 ··· 269 268 net_dev->stats.tx_bytes += bytes; 270 269 netdev_completed_queue(ch->priv->net_dev, pkts, bytes); 271 270 271 + netif_tx_unlock(net_dev); 272 272 if (netif_queue_stopped(net_dev)) 273 273 netif_wake_queue(net_dev); 274 274

+2 -11

drivers/net/ethernet/marvell/mvneta.c

··· 3400 3400 txq->last_desc = txq->size - 1; 3401 3401 3402 3402 txq->buf = kmalloc_array(txq->size, sizeof(*txq->buf), GFP_KERNEL); 3403 - if (!txq->buf) { 3404 - dma_free_coherent(pp->dev->dev.parent, 3405 - txq->size * MVNETA_DESC_ALIGNED_SIZE, 3406 - txq->descs, txq->descs_phys); 3403 + if (!txq->buf) 3407 3404 return -ENOMEM; 3408 - } 3409 3405 3410 3406 /* Allocate DMA buffers for TSO MAC/IP/TCP headers */ 3411 3407 txq->tso_hdrs = dma_alloc_coherent(pp->dev->dev.parent, 3412 3408 txq->size * TSO_HEADER_SIZE, 3413 3409 &txq->tso_hdrs_phys, GFP_KERNEL); 3414 - if (!txq->tso_hdrs) { 3415 - kfree(txq->buf); 3416 - dma_free_coherent(pp->dev->dev.parent, 3417 - txq->size * MVNETA_DESC_ALIGNED_SIZE, 3418 - txq->descs, txq->descs_phys); 3410 + if (!txq->tso_hdrs) 3419 3411 return -ENOMEM; 3420 - } 3421 3412 3422 3413 /* Setup XPS mapping */ 3423 3414 if (txq_number > 1)

+10 -2

drivers/net/ethernet/marvell/octeontx2/af/mbox.c

··· 17 17 18 18 static const u16 msgs_offset = ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN); 19 19 20 - void otx2_mbox_reset(struct otx2_mbox *mbox, int devid) 20 + void __otx2_mbox_reset(struct otx2_mbox *mbox, int devid) 21 21 { 22 22 void *hw_mbase = mbox->hwbase + (devid * MBOX_SIZE); 23 23 struct otx2_mbox_dev *mdev = &mbox->dev[devid]; ··· 26 26 tx_hdr = hw_mbase + mbox->tx_start; 27 27 rx_hdr = hw_mbase + mbox->rx_start; 28 28 29 - spin_lock(&mdev->mbox_lock); 30 29 mdev->msg_size = 0; 31 30 mdev->rsp_size = 0; 32 31 tx_hdr->num_msgs = 0; 33 32 tx_hdr->msg_size = 0; 34 33 rx_hdr->num_msgs = 0; 35 34 rx_hdr->msg_size = 0; 35 + } 36 + EXPORT_SYMBOL(__otx2_mbox_reset); 37 + 38 + void otx2_mbox_reset(struct otx2_mbox *mbox, int devid) 39 + { 40 + struct otx2_mbox_dev *mdev = &mbox->dev[devid]; 41 + 42 + spin_lock(&mdev->mbox_lock); 43 + __otx2_mbox_reset(mbox, devid); 36 44 spin_unlock(&mdev->mbox_lock); 37 45 } 38 46 EXPORT_SYMBOL(otx2_mbox_reset);

+1

drivers/net/ethernet/marvell/octeontx2/af/mbox.h

··· 93 93 }; 94 94 95 95 void otx2_mbox_reset(struct otx2_mbox *mbox, int devid); 96 + void __otx2_mbox_reset(struct otx2_mbox *mbox, int devid); 96 97 void otx2_mbox_destroy(struct otx2_mbox *mbox); 97 98 int otx2_mbox_init(struct otx2_mbox *mbox, void __force *hwbase, 98 99 struct pci_dev *pdev, void __force *reg_base,

+2 -1

drivers/net/ethernet/marvell/octeontx2/af/rvu.h

··· 463 463 int rvu_get_nixlf_count(struct rvu *rvu); 464 464 void rvu_nix_lf_teardown(struct rvu *rvu, u16 pcifunc, int blkaddr, int npalf); 465 465 int nix_get_nixlf(struct rvu *rvu, u16 pcifunc, int *nixlf, int *nix_blkaddr); 466 + int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add); 466 467 467 468 /* NPC APIs */ 468 469 int rvu_npc_init(struct rvu *rvu); ··· 478 477 void rvu_npc_enable_promisc_entry(struct rvu *rvu, u16 pcifunc, int nixlf); 479 478 void rvu_npc_install_bcast_match_entry(struct rvu *rvu, u16 pcifunc, 480 479 int nixlf, u64 chan); 481 - void rvu_npc_disable_bcast_entry(struct rvu *rvu, u16 pcifunc); 480 + void rvu_npc_enable_bcast_entry(struct rvu *rvu, u16 pcifunc, bool enable); 482 481 int rvu_npc_update_rxvlan(struct rvu *rvu, u16 pcifunc, int nixlf); 483 482 void rvu_npc_disable_mcam_entries(struct rvu *rvu, u16 pcifunc, int nixlf); 484 483 void rvu_npc_disable_default_entries(struct rvu *rvu, u16 pcifunc, int nixlf);

+2 -3

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

··· 17 17 #include "npc.h" 18 18 #include "cgx.h" 19 19 20 - static int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add); 21 20 static int rvu_nix_get_bpid(struct rvu *rvu, struct nix_bp_cfg_req *req, 22 21 int type, int chan_id); 23 22 ··· 2019 2020 return 0; 2020 2021 } 2021 2022 2022 - static int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add) 2023 + int nix_update_bcast_mce_list(struct rvu *rvu, u16 pcifunc, bool add) 2023 2024 { 2024 2025 int err = 0, idx, next_idx, last_idx; 2025 2026 struct nix_mce_list *mce_list; ··· 2064 2065 2065 2066 /* Disable MCAM entry in NPC */ 2066 2067 if (!mce_list->count) { 2067 - rvu_npc_disable_bcast_entry(rvu, pcifunc); 2068 + rvu_npc_enable_bcast_entry(rvu, pcifunc, false); 2068 2069 goto end; 2069 2070 } 2070 2071

+19 -7

drivers/net/ethernet/marvell/octeontx2/af/rvu_npc.c

··· 530 530 NIX_INTF_RX, &entry, true); 531 531 } 532 532 533 - void rvu_npc_disable_bcast_entry(struct rvu *rvu, u16 pcifunc) 533 + void rvu_npc_enable_bcast_entry(struct rvu *rvu, u16 pcifunc, bool enable) 534 534 { 535 535 struct npc_mcam *mcam = &rvu->hw->mcam; 536 536 int blkaddr, index; ··· 543 543 pcifunc = pcifunc & ~RVU_PFVF_FUNC_MASK; 544 544 545 545 index = npc_get_nixlf_mcam_index(mcam, pcifunc, 0, NIXLF_BCAST_ENTRY); 546 - npc_enable_mcam_entry(rvu, mcam, blkaddr, index, false); 546 + npc_enable_mcam_entry(rvu, mcam, blkaddr, index, enable); 547 547 } 548 548 549 549 void rvu_npc_update_flowkey_alg_idx(struct rvu *rvu, u16 pcifunc, int nixlf, ··· 622 622 nixlf, NIXLF_UCAST_ENTRY); 623 623 npc_enable_mcam_entry(rvu, mcam, blkaddr, index, enable); 624 624 625 - /* For PF, ena/dis promisc and bcast MCAM match entries */ 626 - if (pcifunc & RVU_PFVF_FUNC_MASK) 625 + /* For PF, ena/dis promisc and bcast MCAM match entries. 626 + * For VFs add/delete from bcast list when RX multicast 627 + * feature is present. 628 + */ 629 + if (pcifunc & RVU_PFVF_FUNC_MASK && !rvu->hw->cap.nix_rx_multicast) 627 630 return; 628 631 629 632 /* For bcast, enable/disable only if it's action is not 630 633 * packet replication, incase if action is replication 631 - * then this PF's nixlf is removed from bcast replication 634 + * then this PF/VF's nixlf is removed from bcast replication 632 635 * list. 633 636 */ 634 - index = npc_get_nixlf_mcam_index(mcam, pcifunc, 637 + index = npc_get_nixlf_mcam_index(mcam, pcifunc & ~RVU_PFVF_FUNC_MASK, 635 638 nixlf, NIXLF_BCAST_ENTRY); 636 639 bank = npc_get_bank(mcam, index); 637 640 *(u64 *)&action = rvu_read64(rvu, blkaddr, 638 641 NPC_AF_MCAMEX_BANKX_ACTION(index & (mcam->banksize - 1), bank)); 639 - if (action.op != NIX_RX_ACTIONOP_MCAST) 642 + 643 + /* VFs will not have BCAST entry */ 644 + if (action.op != NIX_RX_ACTIONOP_MCAST && 645 + !(pcifunc & RVU_PFVF_FUNC_MASK)) { 640 646 npc_enable_mcam_entry(rvu, mcam, 641 647 blkaddr, index, enable); 648 + } else { 649 + nix_update_bcast_mce_list(rvu, pcifunc, enable); 650 + /* Enable PF's BCAST entry for packet replication */ 651 + rvu_npc_enable_bcast_entry(rvu, pcifunc, enable); 652 + } 653 + 642 654 if (enable) 643 655 rvu_npc_enable_promisc_entry(rvu, pcifunc, nixlf); 644 656 else

+10 -6

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

··· 370 370 dst_mbox = &pf->mbox; 371 371 dst_size = dst_mbox->mbox.tx_size - 372 372 ALIGN(sizeof(*mbox_hdr), MBOX_MSG_ALIGN); 373 - /* Check if msgs fit into destination area */ 374 - if (mbox_hdr->msg_size > dst_size) 373 + /* Check if msgs fit into destination area and has valid size */ 374 + if (mbox_hdr->msg_size > dst_size || !mbox_hdr->msg_size) 375 375 return -EINVAL; 376 376 377 377 dst_mdev = &dst_mbox->mbox.dev[0]; ··· 526 526 527 527 end: 528 528 offset = mbox->rx_start + msg->next_msgoff; 529 + if (mdev->msgs_acked == (vf_mbox->up_num_msgs - 1)) 530 + __otx2_mbox_reset(mbox, 0); 529 531 mdev->msgs_acked++; 530 532 } 531 - 532 - otx2_mbox_reset(mbox, vf_idx); 533 533 } 534 534 535 535 static irqreturn_t otx2_pfvf_mbox_intr_handler(int irq, void *pf_irq) ··· 803 803 msg = (struct mbox_msghdr *)(mdev->mbase + offset); 804 804 otx2_process_pfaf_mbox_msg(pf, msg); 805 805 offset = mbox->rx_start + msg->next_msgoff; 806 + if (mdev->msgs_acked == (af_mbox->num_msgs - 1)) 807 + __otx2_mbox_reset(mbox, 0); 806 808 mdev->msgs_acked++; 807 809 } 808 810 809 - otx2_mbox_reset(mbox, 0); 810 811 } 811 812 812 813 static void otx2_handle_link_event(struct otx2_nic *pf) ··· 1561 1560 1562 1561 err = otx2_rxtx_enable(pf, true); 1563 1562 if (err) 1564 - goto err_free_cints; 1563 + goto err_tx_stop_queues; 1565 1564 1566 1565 return 0; 1567 1566 1567 + err_tx_stop_queues: 1568 + netif_tx_stop_all_queues(netdev); 1569 + netif_carrier_off(netdev); 1568 1570 err_free_cints: 1569 1571 otx2_free_cints(pf, qidx); 1570 1572 vec = pci_irq_vector(pf->pdev,

+1

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

··· 524 524 sqe_hdr->ol3type = NIX_SENDL3TYPE_IP4_CKSUM; 525 525 } else if (skb->protocol == htons(ETH_P_IPV6)) { 526 526 proto = ipv6_hdr(skb)->nexthdr; 527 + sqe_hdr->ol3type = NIX_SENDL3TYPE_IP6; 527 528 } 528 529 529 530 if (proto == IPPROTO_TCP)

+2 -2

drivers/net/ethernet/marvell/octeontx2/nic/otx2_vf.c

··· 99 99 msg = (struct mbox_msghdr *)(mdev->mbase + offset); 100 100 otx2vf_process_vfaf_mbox_msg(af_mbox->pfvf, msg); 101 101 offset = mbox->rx_start + msg->next_msgoff; 102 + if (mdev->msgs_acked == (af_mbox->num_msgs - 1)) 103 + __otx2_mbox_reset(mbox, 0); 102 104 mdev->msgs_acked++; 103 105 } 104 - 105 - otx2_mbox_reset(mbox, 0); 106 106 } 107 107 108 108 static int otx2vf_process_mbox_msg_up(struct otx2_nic *vf,

+144 -54

drivers/net/ethernet/mellanox/mlx5/core/cmd.c

··· 69 69 MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR = 0x10, 70 70 }; 71 71 72 - static struct mlx5_cmd_work_ent *alloc_cmd(struct mlx5_cmd *cmd, 73 - struct mlx5_cmd_msg *in, 74 - struct mlx5_cmd_msg *out, 75 - void *uout, int uout_size, 76 - mlx5_cmd_cbk_t cbk, 77 - void *context, int page_queue) 72 + static struct mlx5_cmd_work_ent * 73 + cmd_alloc_ent(struct mlx5_cmd *cmd, struct mlx5_cmd_msg *in, 74 + struct mlx5_cmd_msg *out, void *uout, int uout_size, 75 + mlx5_cmd_cbk_t cbk, void *context, int page_queue) 78 76 { 79 77 gfp_t alloc_flags = cbk ? GFP_ATOMIC : GFP_KERNEL; 80 78 struct mlx5_cmd_work_ent *ent; ··· 81 83 if (!ent) 82 84 return ERR_PTR(-ENOMEM); 83 85 86 + ent->idx = -EINVAL; 84 87 ent->in = in; 85 88 ent->out = out; 86 89 ent->uout = uout; ··· 90 91 ent->context = context; 91 92 ent->cmd = cmd; 92 93 ent->page_queue = page_queue; 94 + refcount_set(&ent->refcnt, 1); 93 95 94 96 return ent; 97 + } 98 + 99 + static void cmd_free_ent(struct mlx5_cmd_work_ent *ent) 100 + { 101 + kfree(ent); 95 102 } 96 103 97 104 static u8 alloc_token(struct mlx5_cmd *cmd) ··· 114 109 return token; 115 110 } 116 111 117 - static int alloc_ent(struct mlx5_cmd *cmd) 112 + static int cmd_alloc_index(struct mlx5_cmd *cmd) 118 113 { 119 114 unsigned long flags; 120 115 int ret; ··· 128 123 return ret < cmd->max_reg_cmds ? ret : -ENOMEM; 129 124 } 130 125 131 - static void free_ent(struct mlx5_cmd *cmd, int idx) 126 + static void cmd_free_index(struct mlx5_cmd *cmd, int idx) 132 127 { 133 128 unsigned long flags; 134 129 135 130 spin_lock_irqsave(&cmd->alloc_lock, flags); 136 131 set_bit(idx, &cmd->bitmask); 137 132 spin_unlock_irqrestore(&cmd->alloc_lock, flags); 133 + } 134 + 135 + static void cmd_ent_get(struct mlx5_cmd_work_ent *ent) 136 + { 137 + refcount_inc(&ent->refcnt); 138 + } 139 + 140 + static void cmd_ent_put(struct mlx5_cmd_work_ent *ent) 141 + { 142 + if (!refcount_dec_and_test(&ent->refcnt)) 143 + return; 144 + 145 + if (ent->idx >= 0) 146 + cmd_free_index(ent->cmd, ent->idx); 147 + 148 + cmd_free_ent(ent); 138 149 } 139 150 140 151 static struct mlx5_cmd_layout *get_inst(struct mlx5_cmd *cmd, int idx) ··· 238 217 } while (time_before(jiffies, poll_end)); 239 218 240 219 ent->ret = -ETIMEDOUT; 241 - } 242 - 243 - static void free_cmd(struct mlx5_cmd_work_ent *ent) 244 - { 245 - kfree(ent); 246 220 } 247 221 248 222 static int verify_signature(struct mlx5_cmd_work_ent *ent) ··· 853 837 struct mlx5_core_dev *dev = container_of(ent->cmd, struct mlx5_core_dev, 854 838 cmd); 855 839 840 + mlx5_cmd_eq_recover(dev); 841 + 842 + /* Maybe got handled by eq recover ? */ 843 + if (!test_bit(MLX5_CMD_ENT_STATE_PENDING_COMP, &ent->state)) { 844 + mlx5_core_warn(dev, "cmd[%d]: %s(0x%x) Async, recovered after timeout\n", ent->idx, 845 + mlx5_command_str(msg_to_opcode(ent->in)), msg_to_opcode(ent->in)); 846 + goto out; /* phew, already handled */ 847 + } 848 + 856 849 ent->ret = -ETIMEDOUT; 857 - mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n", 858 - mlx5_command_str(msg_to_opcode(ent->in)), 859 - msg_to_opcode(ent->in)); 850 + mlx5_core_warn(dev, "cmd[%d]: %s(0x%x) Async, timeout. Will cause a leak of a command resource\n", 851 + ent->idx, mlx5_command_str(msg_to_opcode(ent->in)), msg_to_opcode(ent->in)); 860 852 mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true); 853 + 854 + out: 855 + cmd_ent_put(ent); /* for the cmd_ent_get() took on schedule delayed work */ 861 856 } 862 857 863 858 static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg); ··· 881 854 return true; 882 855 883 856 return cmd->allowed_opcode == opcode; 857 + } 858 + 859 + static int cmd_alloc_index_retry(struct mlx5_cmd *cmd) 860 + { 861 + unsigned long alloc_end = jiffies + msecs_to_jiffies(1000); 862 + int idx; 863 + 864 + retry: 865 + idx = cmd_alloc_index(cmd); 866 + if (idx < 0 && time_before(jiffies, alloc_end)) { 867 + /* Index allocation can fail on heavy load of commands. This is a temporary 868 + * situation as the current command already holds the semaphore, meaning that 869 + * another command completion is being handled and it is expected to release 870 + * the entry index soon. 871 + */ 872 + cpu_relax(); 873 + goto retry; 874 + } 875 + return idx; 876 + } 877 + 878 + bool mlx5_cmd_is_down(struct mlx5_core_dev *dev) 879 + { 880 + return pci_channel_offline(dev->pdev) || 881 + dev->cmd.state != MLX5_CMDIF_STATE_UP || 882 + dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR; 884 883 } 885 884 886 885 static void cmd_work_handler(struct work_struct *work) ··· 926 873 sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem; 927 874 down(sem); 928 875 if (!ent->page_queue) { 929 - alloc_ret = alloc_ent(cmd); 876 + alloc_ret = cmd_alloc_index_retry(cmd); 930 877 if (alloc_ret < 0) { 931 878 mlx5_core_err_rl(dev, "failed to allocate command entry\n"); 932 879 if (ent->callback) { 933 880 ent->callback(-EAGAIN, ent->context); 934 881 mlx5_free_cmd_msg(dev, ent->out); 935 882 free_msg(dev, ent->in); 936 - free_cmd(ent); 883 + cmd_ent_put(ent); 937 884 } else { 938 885 ent->ret = -EAGAIN; 939 886 complete(&ent->done); ··· 969 916 ent->ts1 = ktime_get_ns(); 970 917 cmd_mode = cmd->mode; 971 918 972 - if (ent->callback) 973 - schedule_delayed_work(&ent->cb_timeout_work, cb_timeout); 919 + if (ent->callback && schedule_delayed_work(&ent->cb_timeout_work, cb_timeout)) 920 + cmd_ent_get(ent); 974 921 set_bit(MLX5_CMD_ENT_STATE_PENDING_COMP, &ent->state); 975 922 976 923 /* Skip sending command to fw if internal error */ 977 - if (pci_channel_offline(dev->pdev) || 978 - dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR || 979 - cmd->state != MLX5_CMDIF_STATE_UP || 980 - !opcode_allowed(&dev->cmd, ent->op)) { 924 + if (mlx5_cmd_is_down(dev) || !opcode_allowed(&dev->cmd, ent->op)) { 981 925 u8 status = 0; 982 926 u32 drv_synd; 983 927 ··· 983 933 MLX5_SET(mbox_out, ent->out, syndrome, drv_synd); 984 934 985 935 mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true); 986 - /* no doorbell, no need to keep the entry */ 987 - free_ent(cmd, ent->idx); 988 - if (ent->callback) 989 - free_cmd(ent); 990 936 return; 991 937 } 992 938 939 + cmd_ent_get(ent); /* for the _real_ FW event on completion */ 993 940 /* ring doorbell after the descriptor is valid */ 994 941 mlx5_core_dbg(dev, "writing 0x%x to command doorbell\n", 1 << ent->idx); 995 942 wmb(); ··· 1030 983 } 1031 984 } 1032 985 986 + enum { 987 + MLX5_CMD_TIMEOUT_RECOVER_MSEC = 5 * 1000, 988 + }; 989 + 990 + static void wait_func_handle_exec_timeout(struct mlx5_core_dev *dev, 991 + struct mlx5_cmd_work_ent *ent) 992 + { 993 + unsigned long timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_RECOVER_MSEC); 994 + 995 + mlx5_cmd_eq_recover(dev); 996 + 997 + /* Re-wait on the ent->done after executing the recovery flow. If the 998 + * recovery flow (or any other recovery flow running simultaneously) 999 + * has recovered an EQE, it should cause the entry to be completed by 1000 + * the command interface. 1001 + */ 1002 + if (wait_for_completion_timeout(&ent->done, timeout)) { 1003 + mlx5_core_warn(dev, "cmd[%d]: %s(0x%x) recovered after timeout\n", ent->idx, 1004 + mlx5_command_str(msg_to_opcode(ent->in)), msg_to_opcode(ent->in)); 1005 + return; 1006 + } 1007 + 1008 + mlx5_core_warn(dev, "cmd[%d]: %s(0x%x) No done completion\n", ent->idx, 1009 + mlx5_command_str(msg_to_opcode(ent->in)), msg_to_opcode(ent->in)); 1010 + 1011 + ent->ret = -ETIMEDOUT; 1012 + mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true); 1013 + } 1014 + 1033 1015 static int wait_func(struct mlx5_core_dev *dev, struct mlx5_cmd_work_ent *ent) 1034 1016 { 1035 1017 unsigned long timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC); ··· 1070 994 ent->ret = -ECANCELED; 1071 995 goto out_err; 1072 996 } 1073 - if (cmd->mode == CMD_MODE_POLLING || ent->polling) { 997 + if (cmd->mode == CMD_MODE_POLLING || ent->polling) 1074 998 wait_for_completion(&ent->done); 1075 - } else if (!wait_for_completion_timeout(&ent->done, timeout)) { 1076 - ent->ret = -ETIMEDOUT; 1077 - mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true); 1078 - } 999 + else if (!wait_for_completion_timeout(&ent->done, timeout)) 1000 + wait_func_handle_exec_timeout(dev, ent); 1079 1001 1080 1002 out_err: 1081 1003 err = ent->ret; ··· 1113 1039 if (callback && page_queue) 1114 1040 return -EINVAL; 1115 1041 1116 - ent = alloc_cmd(cmd, in, out, uout, uout_size, callback, context, 1117 - page_queue); 1042 + ent = cmd_alloc_ent(cmd, in, out, uout, uout_size, 1043 + callback, context, page_queue); 1118 1044 if (IS_ERR(ent)) 1119 1045 return PTR_ERR(ent); 1046 + 1047 + /* put for this ent is when consumed, depending on the use case 1048 + * 1) (!callback) blocking flow: by caller after wait_func completes 1049 + * 2) (callback) flow: by mlx5_cmd_comp_handler() when ent is handled 1050 + */ 1120 1051 1121 1052 ent->token = token; 1122 1053 ent->polling = force_polling; ··· 1141 1062 } 1142 1063 1143 1064 if (callback) 1144 - goto out; 1065 + goto out; /* mlx5_cmd_comp_handler() will put(ent) */ 1145 1066 1146 1067 err = wait_func(dev, ent); 1147 - if (err == -ETIMEDOUT) 1148 - goto out; 1149 - if (err == -ECANCELED) 1068 + if (err == -ETIMEDOUT || err == -ECANCELED) 1150 1069 goto out_free; 1151 1070 1152 1071 ds = ent->ts2 - ent->ts1; ··· 1162 1085 *status = ent->status; 1163 1086 1164 1087 out_free: 1165 - free_cmd(ent); 1088 + cmd_ent_put(ent); 1166 1089 out: 1167 1090 return err; 1168 1091 } ··· 1593 1516 if (!forced) { 1594 1517 mlx5_core_err(dev, "Command completion arrived after timeout (entry idx = %d).\n", 1595 1518 ent->idx); 1596 - free_ent(cmd, ent->idx); 1597 - free_cmd(ent); 1519 + cmd_ent_put(ent); 1598 1520 } 1599 1521 continue; 1600 1522 } 1601 1523 1602 - if (ent->callback) 1603 - cancel_delayed_work(&ent->cb_timeout_work); 1524 + if (ent->callback && cancel_delayed_work(&ent->cb_timeout_work)) 1525 + cmd_ent_put(ent); /* timeout work was canceled */ 1526 + 1527 + if (!forced || /* Real FW completion */ 1528 + pci_channel_offline(dev->pdev) || /* FW is inaccessible */ 1529 + dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) 1530 + cmd_ent_put(ent); 1531 + 1604 1532 if (ent->page_queue) 1605 1533 sem = &cmd->pages_sem; 1606 1534 else ··· 1626 1544 mlx5_core_dbg(dev, "command completed. ret 0x%x, delivery status %s(0x%x)\n", 1627 1545 ent->ret, deliv_status_to_str(ent->status), ent->status); 1628 1546 } 1629 - 1630 - /* only real completion will free the entry slot */ 1631 - if (!forced) 1632 - free_ent(cmd, ent->idx); 1633 1547 1634 1548 if (ent->callback) { 1635 1549 ds = ent->ts2 - ent->ts1; ··· 1654 1576 free_msg(dev, ent->in); 1655 1577 1656 1578 err = err ? err : ent->status; 1657 - if (!forced) 1658 - free_cmd(ent); 1579 + /* final consumer is done, release ent */ 1580 + cmd_ent_put(ent); 1659 1581 callback(err, context); 1660 1582 } else { 1583 + /* release wait_func() so mlx5_cmd_invoke() 1584 + * can make the final ent_put() 1585 + */ 1661 1586 complete(&ent->done); 1662 1587 } 1663 1588 up(sem); ··· 1670 1589 1671 1590 void mlx5_cmd_trigger_completions(struct mlx5_core_dev *dev) 1672 1591 { 1592 + struct mlx5_cmd *cmd = &dev->cmd; 1593 + unsigned long bitmask; 1673 1594 unsigned long flags; 1674 1595 u64 vector; 1596 + int i; 1675 1597 1676 1598 /* wait for pending handlers to complete */ 1677 1599 mlx5_eq_synchronize_cmd_irq(dev); ··· 1683 1599 if (!vector) 1684 1600 goto no_trig; 1685 1601 1602 + bitmask = vector; 1603 + /* we must increment the allocated entries refcount before triggering the completions 1604 + * to guarantee pending commands will not get freed in the meanwhile. 1605 + * For that reason, it also has to be done inside the alloc_lock. 1606 + */ 1607 + for_each_set_bit(i, &bitmask, (1 << cmd->log_sz)) 1608 + cmd_ent_get(cmd->ent_arr[i]); 1686 1609 vector |= MLX5_TRIGGERED_CMD_COMP; 1687 1610 spin_unlock_irqrestore(&dev->cmd.alloc_lock, flags); 1688 1611 1689 1612 mlx5_core_dbg(dev, "vector 0x%llx\n", vector); 1690 1613 mlx5_cmd_comp_handler(dev, vector, true); 1614 + for_each_set_bit(i, &bitmask, (1 << cmd->log_sz)) 1615 + cmd_ent_put(cmd->ent_arr[i]); 1691 1616 return; 1692 1617 1693 1618 no_trig: ··· 1804 1711 u8 token; 1805 1712 1806 1713 opcode = MLX5_GET(mbox_in, in, opcode); 1807 - if (pci_channel_offline(dev->pdev) || 1808 - dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR || 1809 - dev->cmd.state != MLX5_CMDIF_STATE_UP || 1810 - !opcode_allowed(&dev->cmd, opcode)) { 1714 + if (mlx5_cmd_is_down(dev) || !opcode_allowed(&dev->cmd, opcode)) { 1811 1715 err = mlx5_internal_err_ret_value(dev, opcode, &drv_synd, &status); 1812 1716 MLX5_SET(mbox_out, out, status, status); 1813 1717 MLX5_SET(mbox_out, out, syndrome, drv_synd);

+7 -1

drivers/net/ethernet/mellanox/mlx5/core/en.h

··· 91 91 #define MLX5_MPWRQ_PAGES_PER_WQE BIT(MLX5_MPWRQ_WQE_PAGE_ORDER) 92 92 93 93 #define MLX5_MTT_OCTW(npages) (ALIGN(npages, 8) / 2) 94 - #define MLX5E_REQUIRED_WQE_MTTS (ALIGN(MLX5_MPWRQ_PAGES_PER_WQE, 8)) 94 + /* Add another page to MLX5E_REQUIRED_WQE_MTTS as a buffer between 95 + * WQEs, This page will absorb write overflow by the hardware, when 96 + * receiving packets larger than MTU. These oversize packets are 97 + * dropped by the driver at a later stage. 98 + */ 99 + #define MLX5E_REQUIRED_WQE_MTTS (ALIGN(MLX5_MPWRQ_PAGES_PER_WQE + 1, 8)) 95 100 #define MLX5E_LOG_ALIGNED_MPWQE_PPW (ilog2(MLX5E_REQUIRED_WQE_MTTS)) 96 101 #define MLX5E_REQUIRED_MTTS(wqes) (wqes * MLX5E_REQUIRED_WQE_MTTS) 97 102 #define MLX5E_MAX_RQ_NUM_MTTS \ ··· 622 617 u32 rqn; 623 618 struct mlx5_core_dev *mdev; 624 619 struct mlx5_core_mkey umr_mkey; 620 + struct mlx5e_dma_info wqe_overflow; 625 621 626 622 /* XDP read-mostly */ 627 623 struct xdp_rxq_info xdp_rxq;

+3

drivers/net/ethernet/mellanox/mlx5/core/en/port.c

··· 569 569 if (fec_policy >= (1 << MLX5E_FEC_LLRS_272_257_1) && !fec_50g_per_lane) 570 570 return -EOPNOTSUPP; 571 571 572 + if (fec_policy && !mlx5e_fec_in_caps(dev, fec_policy)) 573 + return -EOPNOTSUPP; 574 + 572 575 MLX5_SET(pplm_reg, in, local_port, 1); 573 576 err = mlx5_core_access_reg(dev, in, sz, out, sz, MLX5_REG_PPLM, 0, 0); 574 577 if (err)

+50 -31

drivers/net/ethernet/mellanox/mlx5/core/en/rep/neigh.c

··· 110 110 rtnl_unlock(); 111 111 } 112 112 113 + struct neigh_update_work { 114 + struct work_struct work; 115 + struct neighbour *n; 116 + struct mlx5e_neigh_hash_entry *nhe; 117 + }; 118 + 119 + static void mlx5e_release_neigh_update_work(struct neigh_update_work *update_work) 120 + { 121 + neigh_release(update_work->n); 122 + mlx5e_rep_neigh_entry_release(update_work->nhe); 123 + kfree(update_work); 124 + } 125 + 113 126 static void mlx5e_rep_neigh_update(struct work_struct *work) 114 127 { 115 - struct mlx5e_neigh_hash_entry *nhe = 116 - container_of(work, struct mlx5e_neigh_hash_entry, neigh_update_work); 117 - struct neighbour *n = nhe->n; 128 + struct neigh_update_work *update_work = container_of(work, struct neigh_update_work, 129 + work); 130 + struct mlx5e_neigh_hash_entry *nhe = update_work->nhe; 131 + struct neighbour *n = update_work->n; 118 132 struct mlx5e_encap_entry *e; 119 133 unsigned char ha[ETH_ALEN]; 120 134 struct mlx5e_priv *priv; ··· 160 146 mlx5e_rep_update_flows(priv, e, neigh_connected, ha); 161 147 mlx5e_encap_put(priv, e); 162 148 } 163 - mlx5e_rep_neigh_entry_release(nhe); 164 149 rtnl_unlock(); 165 - neigh_release(n); 150 + mlx5e_release_neigh_update_work(update_work); 166 151 } 167 152 168 - static void mlx5e_rep_queue_neigh_update_work(struct mlx5e_priv *priv, 169 - struct mlx5e_neigh_hash_entry *nhe, 170 - struct neighbour *n) 153 + static struct neigh_update_work *mlx5e_alloc_neigh_update_work(struct mlx5e_priv *priv, 154 + struct neighbour *n) 171 155 { 172 - /* Take a reference to ensure the neighbour and mlx5 encap 173 - * entry won't be destructed until we drop the reference in 174 - * delayed work. 175 - */ 176 - neigh_hold(n); 156 + struct neigh_update_work *update_work; 157 + struct mlx5e_neigh_hash_entry *nhe; 158 + struct mlx5e_neigh m_neigh = {}; 177 159 178 - /* This assignment is valid as long as the the neigh reference 179 - * is taken 180 - */ 181 - nhe->n = n; 160 + update_work = kzalloc(sizeof(*update_work), GFP_ATOMIC); 161 + if (WARN_ON(!update_work)) 162 + return NULL; 182 163 183 - if (!queue_work(priv->wq, &nhe->neigh_update_work)) { 184 - mlx5e_rep_neigh_entry_release(nhe); 185 - neigh_release(n); 164 + m_neigh.dev = n->dev; 165 + m_neigh.family = n->ops->family; 166 + memcpy(&m_neigh.dst_ip, n->primary_key, n->tbl->key_len); 167 + 168 + /* Obtain reference to nhe as last step in order not to release it in 169 + * atomic context. 170 + */ 171 + rcu_read_lock(); 172 + nhe = mlx5e_rep_neigh_entry_lookup(priv, &m_neigh); 173 + rcu_read_unlock(); 174 + if (!nhe) { 175 + kfree(update_work); 176 + return NULL; 186 177 } 178 + 179 + INIT_WORK(&update_work->work, mlx5e_rep_neigh_update); 180 + neigh_hold(n); 181 + update_work->n = n; 182 + update_work->nhe = nhe; 183 + 184 + return update_work; 187 185 } 188 186 189 187 static int mlx5e_rep_netevent_event(struct notifier_block *nb, ··· 207 181 struct net_device *netdev = rpriv->netdev; 208 182 struct mlx5e_priv *priv = netdev_priv(netdev); 209 183 struct mlx5e_neigh_hash_entry *nhe = NULL; 210 - struct mlx5e_neigh m_neigh = {}; 184 + struct neigh_update_work *update_work; 211 185 struct neigh_parms *p; 212 186 struct neighbour *n; 213 187 bool found = false; ··· 222 196 #endif 223 197 return NOTIFY_DONE; 224 198 225 - m_neigh.dev = n->dev; 226 - m_neigh.family = n->ops->family; 227 - memcpy(&m_neigh.dst_ip, n->primary_key, n->tbl->key_len); 228 - 229 - rcu_read_lock(); 230 - nhe = mlx5e_rep_neigh_entry_lookup(priv, &m_neigh); 231 - rcu_read_unlock(); 232 - if (!nhe) 199 + update_work = mlx5e_alloc_neigh_update_work(priv, n); 200 + if (!update_work) 233 201 return NOTIFY_DONE; 234 202 235 - mlx5e_rep_queue_neigh_update_work(priv, nhe, n); 203 + queue_work(priv->wq, &update_work->work); 236 204 break; 237 205 238 206 case NETEVENT_DELAY_PROBE_TIME_UPDATE: ··· 372 352 373 353 (*nhe)->priv = priv; 374 354 memcpy(&(*nhe)->m_neigh, &e->m_neigh, sizeof(e->m_neigh)); 375 - INIT_WORK(&(*nhe)->neigh_update_work, mlx5e_rep_neigh_update); 376 355 spin_lock_init(&(*nhe)->encap_list_lock); 377 356 INIT_LIST_HEAD(&(*nhe)->encap_list); 378 357 refcount_set(&(*nhe)->refcnt, 1);

+3 -1

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

··· 246 246 case FLOW_ACT_MANGLE_HDR_TYPE_IP6: 247 247 ip6_offset = (offset - offsetof(struct ipv6hdr, saddr)); 248 248 ip6_offset /= 4; 249 - if (ip6_offset < 8) 249 + if (ip6_offset < 4) 250 250 tuple->ip.src_v6.s6_addr32[ip6_offset] = cpu_to_be32(val); 251 + else if (ip6_offset < 8) 252 + tuple->ip.dst_v6.s6_addr32[ip6_offset - 4] = cpu_to_be32(val); 251 253 else 252 254 return -EOPNOTSUPP; 253 255 break;

+10 -4

drivers/net/ethernet/mellanox/mlx5/core/en_fs.c

··· 217 217 break; 218 218 } 219 219 220 + if (WARN_ONCE(*rule_p, "VLAN rule already exists type %d", rule_type)) 221 + return 0; 222 + 220 223 *rule_p = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1); 221 224 222 225 if (IS_ERR(*rule_p)) { ··· 400 397 for_each_set_bit(i, priv->fs.vlan.active_svlans, VLAN_N_VID) 401 398 mlx5e_add_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, i); 402 399 403 - if (priv->fs.vlan.cvlan_filter_disabled && 404 - !(priv->netdev->flags & IFF_PROMISC)) 400 + if (priv->fs.vlan.cvlan_filter_disabled) 405 401 mlx5e_add_any_vid_rules(priv); 406 402 } 407 403 ··· 417 415 for_each_set_bit(i, priv->fs.vlan.active_svlans, VLAN_N_VID) 418 416 mlx5e_del_vlan_rule(priv, MLX5E_VLAN_RULE_TYPE_MATCH_STAG_VID, i); 419 417 420 - if (priv->fs.vlan.cvlan_filter_disabled && 421 - !(priv->netdev->flags & IFF_PROMISC)) 418 + WARN_ON_ONCE(!(test_bit(MLX5E_STATE_DESTROYING, &priv->state))); 419 + 420 + /* must be called after DESTROY bit is set and 421 + * set_rx_mode is called and flushed 422 + */ 423 + if (priv->fs.vlan.cvlan_filter_disabled) 422 424 mlx5e_del_any_vid_rules(priv); 423 425 } 424 426

+85 -19

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

··· 246 246 247 247 static int mlx5e_create_umr_mkey(struct mlx5_core_dev *mdev, 248 248 u64 npages, u8 page_shift, 249 - struct mlx5_core_mkey *umr_mkey) 249 + struct mlx5_core_mkey *umr_mkey, 250 + dma_addr_t filler_addr) 250 251 { 251 - int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 252 + struct mlx5_mtt *mtt; 253 + int inlen; 252 254 void *mkc; 253 255 u32 *in; 254 256 int err; 257 + int i; 258 + 259 + inlen = MLX5_ST_SZ_BYTES(create_mkey_in) + sizeof(*mtt) * npages; 255 260 256 261 in = kvzalloc(inlen, GFP_KERNEL); 257 262 if (!in) ··· 276 271 MLX5_SET(mkc, mkc, translations_octword_size, 277 272 MLX5_MTT_OCTW(npages)); 278 273 MLX5_SET(mkc, mkc, log_page_size, page_shift); 274 + MLX5_SET(create_mkey_in, in, translations_octword_actual_size, 275 + MLX5_MTT_OCTW(npages)); 276 + 277 + /* Initialize the mkey with all MTTs pointing to a default 278 + * page (filler_addr). When the channels are activated, UMR 279 + * WQEs will redirect the RX WQEs to the actual memory from 280 + * the RQ's pool, while the gaps (wqe_overflow) remain mapped 281 + * to the default page. 282 + */ 283 + mtt = MLX5_ADDR_OF(create_mkey_in, in, klm_pas_mtt); 284 + for (i = 0 ; i < npages ; i++) 285 + mtt[i].ptag = cpu_to_be64(filler_addr); 279 286 280 287 err = mlx5_core_create_mkey(mdev, umr_mkey, in, inlen); 281 288 ··· 299 282 { 300 283 u64 num_mtts = MLX5E_REQUIRED_MTTS(mlx5_wq_ll_get_size(&rq->mpwqe.wq)); 301 284 302 - return mlx5e_create_umr_mkey(mdev, num_mtts, PAGE_SHIFT, &rq->umr_mkey); 285 + return mlx5e_create_umr_mkey(mdev, num_mtts, PAGE_SHIFT, &rq->umr_mkey, 286 + rq->wqe_overflow.addr); 303 287 } 304 288 305 289 static inline u64 mlx5e_get_mpwqe_offset(struct mlx5e_rq *rq, u16 wqe_ix) ··· 368 350 mlx5e_reporter_rq_cqe_err(rq); 369 351 } 370 352 353 + static int mlx5e_alloc_mpwqe_rq_drop_page(struct mlx5e_rq *rq) 354 + { 355 + rq->wqe_overflow.page = alloc_page(GFP_KERNEL); 356 + if (!rq->wqe_overflow.page) 357 + return -ENOMEM; 358 + 359 + rq->wqe_overflow.addr = dma_map_page(rq->pdev, rq->wqe_overflow.page, 0, 360 + PAGE_SIZE, rq->buff.map_dir); 361 + if (dma_mapping_error(rq->pdev, rq->wqe_overflow.addr)) { 362 + __free_page(rq->wqe_overflow.page); 363 + return -ENOMEM; 364 + } 365 + return 0; 366 + } 367 + 368 + static void mlx5e_free_mpwqe_rq_drop_page(struct mlx5e_rq *rq) 369 + { 370 + dma_unmap_page(rq->pdev, rq->wqe_overflow.addr, PAGE_SIZE, 371 + rq->buff.map_dir); 372 + __free_page(rq->wqe_overflow.page); 373 + } 374 + 371 375 static int mlx5e_alloc_rq(struct mlx5e_channel *c, 372 376 struct mlx5e_params *params, 373 377 struct mlx5e_xsk_param *xsk, ··· 436 396 rq_xdp_ix += params->num_channels * MLX5E_RQ_GROUP_XSK; 437 397 err = xdp_rxq_info_reg(&rq->xdp_rxq, rq->netdev, rq_xdp_ix); 438 398 if (err < 0) 439 - goto err_rq_wq_destroy; 399 + goto err_rq_xdp_prog; 440 400 441 401 rq->buff.map_dir = params->xdp_prog ? DMA_BIDIRECTIONAL : DMA_FROM_DEVICE; 442 402 rq->buff.headroom = mlx5e_get_rq_headroom(mdev, params, xsk); ··· 446 406 case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ: 447 407 err = mlx5_wq_ll_create(mdev, &rqp->wq, rqc_wq, &rq->mpwqe.wq, 448 408 &rq->wq_ctrl); 409 + if (err) 410 + goto err_rq_xdp; 411 + 412 + err = mlx5e_alloc_mpwqe_rq_drop_page(rq); 449 413 if (err) 450 414 goto err_rq_wq_destroy; 451 415 ··· 468 424 469 425 err = mlx5e_create_rq_umr_mkey(mdev, rq); 470 426 if (err) 471 - goto err_rq_wq_destroy; 427 + goto err_rq_drop_page; 472 428 rq->mkey_be = cpu_to_be32(rq->umr_mkey.key); 473 429 474 430 err = mlx5e_rq_alloc_mpwqe_info(rq, c); 475 431 if (err) 476 - goto err_free; 432 + goto err_rq_mkey; 477 433 break; 478 434 default: /* MLX5_WQ_TYPE_CYCLIC */ 479 435 err = mlx5_wq_cyc_create(mdev, &rqp->wq, rqc_wq, &rq->wqe.wq, 480 436 &rq->wq_ctrl); 481 437 if (err) 482 - goto err_rq_wq_destroy; 438 + goto err_rq_xdp; 483 439 484 440 rq->wqe.wq.db = &rq->wqe.wq.db[MLX5_RCV_DBR]; 485 441 ··· 494 450 GFP_KERNEL, cpu_to_node(c->cpu)); 495 451 if (!rq->wqe.frags) { 496 452 err = -ENOMEM; 497 - goto err_free; 453 + goto err_rq_wq_destroy; 498 454 } 499 455 500 456 err = mlx5e_init_di_list(rq, wq_sz, c->cpu); 501 457 if (err) 502 - goto err_free; 458 + goto err_rq_frags; 503 459 504 460 rq->mkey_be = c->mkey_be; 505 461 } 506 462 507 463 err = mlx5e_rq_set_handlers(rq, params, xsk); 508 464 if (err) 509 - goto err_free; 465 + goto err_free_by_rq_type; 510 466 511 467 if (xsk) { 512 468 err = xdp_rxq_info_reg_mem_model(&rq->xdp_rxq, ··· 530 486 if (IS_ERR(rq->page_pool)) { 531 487 err = PTR_ERR(rq->page_pool); 532 488 rq->page_pool = NULL; 533 - goto err_free; 489 + goto err_free_by_rq_type; 534 490 } 535 491 err = xdp_rxq_info_reg_mem_model(&rq->xdp_rxq, 536 492 MEM_TYPE_PAGE_POOL, rq->page_pool); 537 493 } 538 494 if (err) 539 - goto err_free; 495 + goto err_free_by_rq_type; 540 496 541 497 for (i = 0; i < wq_sz; i++) { 542 498 if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) { ··· 586 542 587 543 return 0; 588 544 589 - err_free: 545 + err_free_by_rq_type: 590 546 switch (rq->wq_type) { 591 547 case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ: 592 548 kvfree(rq->mpwqe.info); 549 + err_rq_mkey: 593 550 mlx5_core_destroy_mkey(mdev, &rq->umr_mkey); 551 + err_rq_drop_page: 552 + mlx5e_free_mpwqe_rq_drop_page(rq); 594 553 break; 595 554 default: /* MLX5_WQ_TYPE_CYCLIC */ 596 - kvfree(rq->wqe.frags); 597 555 mlx5e_free_di_list(rq); 556 + err_rq_frags: 557 + kvfree(rq->wqe.frags); 598 558 } 599 - 600 559 err_rq_wq_destroy: 560 + mlx5_wq_destroy(&rq->wq_ctrl); 561 + err_rq_xdp: 562 + xdp_rxq_info_unreg(&rq->xdp_rxq); 563 + err_rq_xdp_prog: 601 564 if (params->xdp_prog) 602 565 bpf_prog_put(params->xdp_prog); 603 - xdp_rxq_info_unreg(&rq->xdp_rxq); 604 - page_pool_destroy(rq->page_pool); 605 - mlx5_wq_destroy(&rq->wq_ctrl); 606 566 607 567 return err; 608 568 } ··· 628 580 case MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ: 629 581 kvfree(rq->mpwqe.info); 630 582 mlx5_core_destroy_mkey(rq->mdev, &rq->umr_mkey); 583 + mlx5e_free_mpwqe_rq_drop_page(rq); 631 584 break; 632 585 default: /* MLX5_WQ_TYPE_CYCLIC */ 633 586 kvfree(rq->wqe.frags); ··· 4226 4177 } 4227 4178 #endif 4228 4179 4180 + static bool mlx5e_gre_tunnel_inner_proto_offload_supported(struct mlx5_core_dev *mdev, 4181 + struct sk_buff *skb) 4182 + { 4183 + switch (skb->inner_protocol) { 4184 + case htons(ETH_P_IP): 4185 + case htons(ETH_P_IPV6): 4186 + case htons(ETH_P_TEB): 4187 + return true; 4188 + case htons(ETH_P_MPLS_UC): 4189 + case htons(ETH_P_MPLS_MC): 4190 + return MLX5_CAP_ETH(mdev, tunnel_stateless_mpls_over_gre); 4191 + } 4192 + return false; 4193 + } 4194 + 4229 4195 static netdev_features_t mlx5e_tunnel_features_check(struct mlx5e_priv *priv, 4230 4196 struct sk_buff *skb, 4231 4197 netdev_features_t features) ··· 4263 4199 4264 4200 switch (proto) { 4265 4201 case IPPROTO_GRE: 4266 - return features; 4202 + if (mlx5e_gre_tunnel_inner_proto_offload_supported(priv->mdev, skb)) 4203 + return features; 4204 + break; 4267 4205 case IPPROTO_IPIP: 4268 4206 case IPPROTO_IPV6: 4269 4207 if (mlx5e_tunnel_proto_supported(priv->mdev, IPPROTO_IPIP))

-6

drivers/net/ethernet/mellanox/mlx5/core/en_rep.h

··· 135 135 /* encap list sharing the same neigh */ 136 136 struct list_head encap_list; 137 137 138 - /* valid only when the neigh reference is taken during 139 - * neigh_update_work workqueue callback. 140 - */ 141 - struct neighbour *n; 142 - struct work_struct neigh_update_work; 143 - 144 138 /* neigh hash entry can be deleted only when the refcount is zero. 145 139 * refcount is needed to avoid neigh hash entry removal by TC, while 146 140 * it's used by the neigh notification call.

+41 -1

drivers/net/ethernet/mellanox/mlx5/core/eq.c

··· 189 189 return count_eqe; 190 190 } 191 191 192 + static void mlx5_eq_async_int_lock(struct mlx5_eq_async *eq, unsigned long *flags) 193 + __acquires(&eq->lock) 194 + { 195 + if (in_irq()) 196 + spin_lock(&eq->lock); 197 + else 198 + spin_lock_irqsave(&eq->lock, *flags); 199 + } 200 + 201 + static void mlx5_eq_async_int_unlock(struct mlx5_eq_async *eq, unsigned long *flags) 202 + __releases(&eq->lock) 203 + { 204 + if (in_irq()) 205 + spin_unlock(&eq->lock); 206 + else 207 + spin_unlock_irqrestore(&eq->lock, *flags); 208 + } 209 + 210 + enum async_eq_nb_action { 211 + ASYNC_EQ_IRQ_HANDLER = 0, 212 + ASYNC_EQ_RECOVER = 1, 213 + }; 214 + 192 215 static int mlx5_eq_async_int(struct notifier_block *nb, 193 216 unsigned long action, void *data) 194 217 { ··· 221 198 struct mlx5_eq_table *eqt; 222 199 struct mlx5_core_dev *dev; 223 200 struct mlx5_eqe *eqe; 201 + unsigned long flags; 224 202 int num_eqes = 0; 225 203 226 204 dev = eq->dev; 227 205 eqt = dev->priv.eq_table; 206 + 207 + mlx5_eq_async_int_lock(eq_async, &flags); 228 208 229 209 eqe = next_eqe_sw(eq); 230 210 if (!eqe) ··· 249 223 250 224 out: 251 225 eq_update_ci(eq, 1); 226 + mlx5_eq_async_int_unlock(eq_async, &flags); 252 227 253 - return 0; 228 + return unlikely(action == ASYNC_EQ_RECOVER) ? num_eqes : 0; 229 + } 230 + 231 + void mlx5_cmd_eq_recover(struct mlx5_core_dev *dev) 232 + { 233 + struct mlx5_eq_async *eq = &dev->priv.eq_table->cmd_eq; 234 + int eqes; 235 + 236 + eqes = mlx5_eq_async_int(&eq->irq_nb, ASYNC_EQ_RECOVER, NULL); 237 + if (eqes) 238 + mlx5_core_warn(dev, "Recovered %d EQEs on cmd_eq\n", eqes); 254 239 } 255 240 256 241 static void init_eq_buf(struct mlx5_eq *eq) ··· 606 569 int err; 607 570 608 571 eq->irq_nb.notifier_call = mlx5_eq_async_int; 572 + spin_lock_init(&eq->lock); 609 573 610 574 err = create_async_eq(dev, &eq->core, param); 611 575 if (err) { ··· 694 656 695 657 cleanup_async_eq(dev, &table->pages_eq, "pages"); 696 658 cleanup_async_eq(dev, &table->async_eq, "async"); 659 + mlx5_cmd_allowed_opcode(dev, MLX5_CMD_OP_DESTROY_EQ); 697 660 mlx5_cmd_use_polling(dev); 698 661 cleanup_async_eq(dev, &table->cmd_eq, "cmd"); 662 + mlx5_cmd_allowed_opcode(dev, CMD_ALLOWED_OPCODE_ALL); 699 663 mlx5_eq_notifier_unregister(dev, &table->cq_err_nb); 700 664 } 701 665

+2

drivers/net/ethernet/mellanox/mlx5/core/lib/eq.h

··· 37 37 struct mlx5_eq_async { 38 38 struct mlx5_eq core; 39 39 struct notifier_block irq_nb; 40 + spinlock_t lock; /* To avoid irq EQ handle races with resiliency flows */ 40 41 }; 41 42 42 43 struct mlx5_eq_comp { ··· 82 81 struct cpumask *mlx5_eq_comp_cpumask(struct mlx5_core_dev *dev, int ix); 83 82 84 83 u32 mlx5_eq_poll_irq_disabled(struct mlx5_eq_comp *eq); 84 + void mlx5_cmd_eq_recover(struct mlx5_core_dev *dev); 85 85 void mlx5_eq_synchronize_async_irq(struct mlx5_core_dev *dev); 86 86 void mlx5_eq_synchronize_cmd_irq(struct mlx5_core_dev *dev); 87 87

+1 -1

drivers/net/ethernet/mellanox/mlx5/core/pagealloc.c

··· 432 432 u32 npages; 433 433 u32 i = 0; 434 434 435 - if (dev->state != MLX5_DEVICE_STATE_INTERNAL_ERROR) 435 + if (!mlx5_cmd_is_down(dev)) 436 436 return mlx5_cmd_exec(dev, in, in_size, out, out_size); 437 437 438 438 /* No hard feelings, we want our pages back! */

+1 -1

drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c

··· 115 115 return 0; 116 116 117 117 err_request_irq: 118 - for (; i >= 0; i--) { 118 + while (i--) { 119 119 struct mlx5_irq *irq = mlx5_irq_get(dev, i); 120 120 int irqn = pci_irq_vector(dev->pdev, i); 121 121

+13 -11

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

··· 3690 3690 return dev->netdev_ops == &mlxsw_sp_port_netdev_ops; 3691 3691 } 3692 3692 3693 - static int mlxsw_sp_lower_dev_walk(struct net_device *lower_dev, void *data) 3693 + static int mlxsw_sp_lower_dev_walk(struct net_device *lower_dev, 3694 + struct netdev_nested_priv *priv) 3694 3695 { 3695 - struct mlxsw_sp_port **p_mlxsw_sp_port = data; 3696 3696 int ret = 0; 3697 3697 3698 3698 if (mlxsw_sp_port_dev_check(lower_dev)) { 3699 - *p_mlxsw_sp_port = netdev_priv(lower_dev); 3699 + priv->data = (void *)netdev_priv(lower_dev); 3700 3700 ret = 1; 3701 3701 } 3702 3702 ··· 3705 3705 3706 3706 struct mlxsw_sp_port *mlxsw_sp_port_dev_lower_find(struct net_device *dev) 3707 3707 { 3708 - struct mlxsw_sp_port *mlxsw_sp_port; 3708 + struct netdev_nested_priv priv = { 3709 + .data = NULL, 3710 + }; 3709 3711 3710 3712 if (mlxsw_sp_port_dev_check(dev)) 3711 3713 return netdev_priv(dev); 3712 3714 3713 - mlxsw_sp_port = NULL; 3714 - netdev_walk_all_lower_dev(dev, mlxsw_sp_lower_dev_walk, &mlxsw_sp_port); 3715 + netdev_walk_all_lower_dev(dev, mlxsw_sp_lower_dev_walk, &priv); 3715 3716 3716 - return mlxsw_sp_port; 3717 + return (struct mlxsw_sp_port *)priv.data; 3717 3718 } 3718 3719 3719 3720 struct mlxsw_sp *mlxsw_sp_lower_get(struct net_device *dev) ··· 3727 3726 3728 3727 struct mlxsw_sp_port *mlxsw_sp_port_dev_lower_find_rcu(struct net_device *dev) 3729 3728 { 3730 - struct mlxsw_sp_port *mlxsw_sp_port; 3729 + struct netdev_nested_priv priv = { 3730 + .data = NULL, 3731 + }; 3731 3732 3732 3733 if (mlxsw_sp_port_dev_check(dev)) 3733 3734 return netdev_priv(dev); 3734 3735 3735 - mlxsw_sp_port = NULL; 3736 3736 netdev_walk_all_lower_dev_rcu(dev, mlxsw_sp_lower_dev_walk, 3737 - &mlxsw_sp_port); 3737 + &priv); 3738 3738 3739 - return mlxsw_sp_port; 3739 + return (struct mlxsw_sp_port *)priv.data; 3740 3740 } 3741 3741 3742 3742 struct mlxsw_sp_port *mlxsw_sp_port_lower_dev_hold(struct net_device *dev)

+2 -1

drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_tcam.c

··· 292 292 int err; 293 293 294 294 group->tcam = tcam; 295 - mutex_init(&group->lock); 296 295 INIT_LIST_HEAD(&group->region_list); 297 296 298 297 err = mlxsw_sp_acl_tcam_group_id_get(tcam, &group->id); 299 298 if (err) 300 299 return err; 300 + 301 + mutex_init(&group->lock); 301 302 302 303 return 0; 303 304 }

+8 -3

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

··· 7351 7351 return err; 7352 7352 } 7353 7353 7354 - static int __mlxsw_sp_rif_macvlan_flush(struct net_device *dev, void *data) 7354 + static int __mlxsw_sp_rif_macvlan_flush(struct net_device *dev, 7355 + struct netdev_nested_priv *priv) 7355 7356 { 7356 - struct mlxsw_sp_rif *rif = data; 7357 + struct mlxsw_sp_rif *rif = (struct mlxsw_sp_rif *)priv->data; 7357 7358 7358 7359 if (!netif_is_macvlan(dev)) 7359 7360 return 0; ··· 7365 7364 7366 7365 static int mlxsw_sp_rif_macvlan_flush(struct mlxsw_sp_rif *rif) 7367 7366 { 7367 + struct netdev_nested_priv priv = { 7368 + .data = (void *)rif, 7369 + }; 7370 + 7368 7371 if (!netif_is_macvlan_port(rif->dev)) 7369 7372 return 0; 7370 7373 7371 7374 netdev_warn(rif->dev, "Router interface is deleted. Upper macvlans will not work\n"); 7372 7375 return netdev_walk_all_upper_dev_rcu(rif->dev, 7373 - __mlxsw_sp_rif_macvlan_flush, rif); 7376 + __mlxsw_sp_rif_macvlan_flush, &priv); 7374 7377 } 7375 7378 7376 7379 static void mlxsw_sp_rif_subport_setup(struct mlxsw_sp_rif *rif,

+7 -3

drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

··· 136 136 } 137 137 138 138 static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev, 139 - void *data) 139 + struct netdev_nested_priv *priv) 140 140 { 141 - struct mlxsw_sp *mlxsw_sp = data; 141 + struct mlxsw_sp *mlxsw_sp = priv->data; 142 142 143 143 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev); 144 144 return 0; ··· 147 147 static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp, 148 148 struct net_device *dev) 149 149 { 150 + struct netdev_nested_priv priv = { 151 + .data = (void *)mlxsw_sp, 152 + }; 153 + 150 154 mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev); 151 155 netdev_walk_all_upper_dev_rcu(dev, 152 156 mlxsw_sp_bridge_device_upper_rif_destroy, 153 - mlxsw_sp); 157 + &priv); 154 158 } 155 159 156 160 static int mlxsw_sp_bridge_device_vxlan_init(struct mlxsw_sp_bridge *bridge,

+31 -21

drivers/net/ethernet/realtek/r8169_main.c

··· 2239 2239 default: 2240 2240 break; 2241 2241 } 2242 - 2243 - clk_disable_unprepare(tp->clk); 2244 2242 } 2245 2243 2246 2244 static void rtl_pll_power_up(struct rtl8169_private *tp) 2247 2245 { 2248 - clk_prepare_enable(tp->clk); 2249 - 2250 2246 switch (tp->mac_version) { 2251 2247 case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 2252 2248 case RTL_GIGA_MAC_VER_37: ··· 2900 2904 { 0x08, 0x0001, 0x0002 }, 2901 2905 { 0x09, 0x0000, 0x0080 }, 2902 2906 { 0x19, 0x0000, 0x0224 }, 2903 - { 0x00, 0x0000, 0x0004 }, 2907 + { 0x00, 0x0000, 0x0008 }, 2904 2908 { 0x0c, 0x3df0, 0x0200 }, 2905 2909 }; 2906 2910 ··· 2917 2921 { 0x06, 0x00c0, 0x0020 }, 2918 2922 { 0x0f, 0xffff, 0x5200 }, 2919 2923 { 0x19, 0x0000, 0x0224 }, 2920 - { 0x00, 0x0000, 0x0004 }, 2924 + { 0x00, 0x0000, 0x0008 }, 2921 2925 { 0x0c, 0x3df0, 0x0200 }, 2922 2926 }; 2923 2927 ··· 4822 4826 4823 4827 #ifdef CONFIG_PM 4824 4828 4825 - static int __maybe_unused rtl8169_suspend(struct device *device) 4829 + static int rtl8169_net_resume(struct rtl8169_private *tp) 4826 4830 { 4827 - struct rtl8169_private *tp = dev_get_drvdata(device); 4828 - 4829 - rtnl_lock(); 4830 - rtl8169_net_suspend(tp); 4831 - rtnl_unlock(); 4832 - 4833 - return 0; 4834 - } 4835 - 4836 - static int rtl8169_resume(struct device *device) 4837 - { 4838 - struct rtl8169_private *tp = dev_get_drvdata(device); 4839 - 4840 4831 rtl_rar_set(tp, tp->dev->dev_addr); 4841 4832 4842 4833 if (tp->TxDescArray) ··· 4832 4849 netif_device_attach(tp->dev); 4833 4850 4834 4851 return 0; 4852 + } 4853 + 4854 + static int __maybe_unused rtl8169_suspend(struct device *device) 4855 + { 4856 + struct rtl8169_private *tp = dev_get_drvdata(device); 4857 + 4858 + rtnl_lock(); 4859 + rtl8169_net_suspend(tp); 4860 + if (!device_may_wakeup(tp_to_dev(tp))) 4861 + clk_disable_unprepare(tp->clk); 4862 + rtnl_unlock(); 4863 + 4864 + return 0; 4865 + } 4866 + 4867 + static int __maybe_unused rtl8169_resume(struct device *device) 4868 + { 4869 + struct rtl8169_private *tp = dev_get_drvdata(device); 4870 + 4871 + if (!device_may_wakeup(tp_to_dev(tp))) 4872 + clk_prepare_enable(tp->clk); 4873 + 4874 + /* Reportedly at least Asus X453MA truncates packets otherwise */ 4875 + if (tp->mac_version == RTL_GIGA_MAC_VER_37) 4876 + rtl_init_rxcfg(tp); 4877 + 4878 + return rtl8169_net_resume(tp); 4835 4879 } 4836 4880 4837 4881 static int rtl8169_runtime_suspend(struct device *device) ··· 4884 4874 4885 4875 __rtl8169_set_wol(tp, tp->saved_wolopts); 4886 4876 4887 - return rtl8169_resume(device); 4877 + return rtl8169_net_resume(tp); 4888 4878 } 4889 4879 4890 4880 static int rtl8169_runtime_idle(struct device *device)

+55 -55

drivers/net/ethernet/renesas/ravb_main.c

··· 1342 1342 return error; 1343 1343 } 1344 1344 1345 - /* MDIO bus init function */ 1346 - static int ravb_mdio_init(struct ravb_private *priv) 1347 - { 1348 - struct platform_device *pdev = priv->pdev; 1349 - struct device *dev = &pdev->dev; 1350 - int error; 1351 - 1352 - /* Bitbang init */ 1353 - priv->mdiobb.ops = &bb_ops; 1354 - 1355 - /* MII controller setting */ 1356 - priv->mii_bus = alloc_mdio_bitbang(&priv->mdiobb); 1357 - if (!priv->mii_bus) 1358 - return -ENOMEM; 1359 - 1360 - /* Hook up MII support for ethtool */ 1361 - priv->mii_bus->name = "ravb_mii"; 1362 - priv->mii_bus->parent = dev; 1363 - snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x", 1364 - pdev->name, pdev->id); 1365 - 1366 - /* Register MDIO bus */ 1367 - error = of_mdiobus_register(priv->mii_bus, dev->of_node); 1368 - if (error) 1369 - goto out_free_bus; 1370 - 1371 - return 0; 1372 - 1373 - out_free_bus: 1374 - free_mdio_bitbang(priv->mii_bus); 1375 - return error; 1376 - } 1377 - 1378 - /* MDIO bus release function */ 1379 - static int ravb_mdio_release(struct ravb_private *priv) 1380 - { 1381 - /* Unregister mdio bus */ 1382 - mdiobus_unregister(priv->mii_bus); 1383 - 1384 - /* Free bitbang info */ 1385 - free_mdio_bitbang(priv->mii_bus); 1386 - 1387 - return 0; 1388 - } 1389 - 1390 1345 /* Network device open function for Ethernet AVB */ 1391 1346 static int ravb_open(struct net_device *ndev) 1392 1347 { ··· 1349 1394 struct platform_device *pdev = priv->pdev; 1350 1395 struct device *dev = &pdev->dev; 1351 1396 int error; 1352 - 1353 - /* MDIO bus init */ 1354 - error = ravb_mdio_init(priv); 1355 - if (error) { 1356 - netdev_err(ndev, "failed to initialize MDIO\n"); 1357 - return error; 1358 - } 1359 1397 1360 1398 napi_enable(&priv->napi[RAVB_BE]); 1361 1399 napi_enable(&priv->napi[RAVB_NC]); ··· 1427 1479 out_napi_off: 1428 1480 napi_disable(&priv->napi[RAVB_NC]); 1429 1481 napi_disable(&priv->napi[RAVB_BE]); 1430 - ravb_mdio_release(priv); 1431 1482 return error; 1432 1483 } 1433 1484 ··· 1736 1789 ravb_ring_free(ndev, RAVB_BE); 1737 1790 ravb_ring_free(ndev, RAVB_NC); 1738 1791 1739 - ravb_mdio_release(priv); 1740 - 1741 1792 return 0; 1742 1793 } 1743 1794 ··· 1886 1941 .ndo_set_mac_address = eth_mac_addr, 1887 1942 .ndo_set_features = ravb_set_features, 1888 1943 }; 1944 + 1945 + /* MDIO bus init function */ 1946 + static int ravb_mdio_init(struct ravb_private *priv) 1947 + { 1948 + struct platform_device *pdev = priv->pdev; 1949 + struct device *dev = &pdev->dev; 1950 + int error; 1951 + 1952 + /* Bitbang init */ 1953 + priv->mdiobb.ops = &bb_ops; 1954 + 1955 + /* MII controller setting */ 1956 + priv->mii_bus = alloc_mdio_bitbang(&priv->mdiobb); 1957 + if (!priv->mii_bus) 1958 + return -ENOMEM; 1959 + 1960 + /* Hook up MII support for ethtool */ 1961 + priv->mii_bus->name = "ravb_mii"; 1962 + priv->mii_bus->parent = dev; 1963 + snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x", 1964 + pdev->name, pdev->id); 1965 + 1966 + /* Register MDIO bus */ 1967 + error = of_mdiobus_register(priv->mii_bus, dev->of_node); 1968 + if (error) 1969 + goto out_free_bus; 1970 + 1971 + return 0; 1972 + 1973 + out_free_bus: 1974 + free_mdio_bitbang(priv->mii_bus); 1975 + return error; 1976 + } 1977 + 1978 + /* MDIO bus release function */ 1979 + static int ravb_mdio_release(struct ravb_private *priv) 1980 + { 1981 + /* Unregister mdio bus */ 1982 + mdiobus_unregister(priv->mii_bus); 1983 + 1984 + /* Free bitbang info */ 1985 + free_mdio_bitbang(priv->mii_bus); 1986 + 1987 + return 0; 1988 + } 1889 1989 1890 1990 static const struct of_device_id ravb_match_table[] = { 1891 1991 { .compatible = "renesas,etheravb-r8a7790", .data = (void *)RCAR_GEN2 }, ··· 2174 2184 eth_hw_addr_random(ndev); 2175 2185 } 2176 2186 2187 + /* MDIO bus init */ 2188 + error = ravb_mdio_init(priv); 2189 + if (error) { 2190 + dev_err(&pdev->dev, "failed to initialize MDIO\n"); 2191 + goto out_dma_free; 2192 + } 2193 + 2177 2194 netif_napi_add(ndev, &priv->napi[RAVB_BE], ravb_poll, 64); 2178 2195 netif_napi_add(ndev, &priv->napi[RAVB_NC], ravb_poll, 64); 2179 2196 ··· 2202 2205 out_napi_del: 2203 2206 netif_napi_del(&priv->napi[RAVB_NC]); 2204 2207 netif_napi_del(&priv->napi[RAVB_BE]); 2208 + ravb_mdio_release(priv); 2209 + out_dma_free: 2205 2210 dma_free_coherent(ndev->dev.parent, priv->desc_bat_size, priv->desc_bat, 2206 2211 priv->desc_bat_dma); 2207 2212 ··· 2235 2236 unregister_netdev(ndev); 2236 2237 netif_napi_del(&priv->napi[RAVB_NC]); 2237 2238 netif_napi_del(&priv->napi[RAVB_BE]); 2239 + ravb_mdio_release(priv); 2238 2240 pm_runtime_disable(&pdev->dev); 2239 2241 free_netdev(ndev); 2240 2242 platform_set_drvdata(pdev, NULL);

+6 -3

drivers/net/ethernet/rocker/rocker_main.c

··· 3099 3099 struct rocker_port *port; 3100 3100 }; 3101 3101 3102 - static int rocker_lower_dev_walk(struct net_device *lower_dev, void *_data) 3102 + static int rocker_lower_dev_walk(struct net_device *lower_dev, 3103 + struct netdev_nested_priv *priv) 3103 3104 { 3104 - struct rocker_walk_data *data = _data; 3105 + struct rocker_walk_data *data = (struct rocker_walk_data *)priv->data; 3105 3106 int ret = 0; 3106 3107 3107 3108 if (rocker_port_dev_check_under(lower_dev, data->rocker)) { ··· 3116 3115 struct rocker_port *rocker_port_dev_lower_find(struct net_device *dev, 3117 3116 struct rocker *rocker) 3118 3117 { 3118 + struct netdev_nested_priv priv; 3119 3119 struct rocker_walk_data data; 3120 3120 3121 3121 if (rocker_port_dev_check_under(dev, rocker)) ··· 3124 3122 3125 3123 data.rocker = rocker; 3126 3124 data.port = NULL; 3127 - netdev_walk_all_lower_dev(dev, rocker_lower_dev_walk, &data); 3125 + priv.data = (void *)&data; 3126 + netdev_walk_all_lower_dev(dev, rocker_lower_dev_walk, &priv); 3128 3127 3129 3128 return data.port; 3130 3129 }

-1

drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c

··· 653 653 654 654 pci_free_irq_vectors(pdev); 655 655 656 - clk_disable_unprepare(priv->plat->stmmac_clk); 657 656 clk_unregister_fixed_rate(priv->plat->stmmac_clk); 658 657 659 658 pcim_iounmap_regions(pdev, BIT(0));

+2

drivers/net/ethernet/stmicro/stmmac/stmmac.h

··· 203 203 int eee_enabled; 204 204 int eee_active; 205 205 int tx_lpi_timer; 206 + int tx_lpi_enabled; 207 + int eee_tw_timer; 206 208 unsigned int mode; 207 209 unsigned int chain_mode; 208 210 int extend_desc;

+15 -12

drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c

··· 665 665 edata->eee_enabled = priv->eee_enabled; 666 666 edata->eee_active = priv->eee_active; 667 667 edata->tx_lpi_timer = priv->tx_lpi_timer; 668 + edata->tx_lpi_enabled = priv->tx_lpi_enabled; 668 669 669 670 return phylink_ethtool_get_eee(priv->phylink, edata); 670 671 } ··· 676 675 struct stmmac_priv *priv = netdev_priv(dev); 677 676 int ret; 678 677 679 - if (!edata->eee_enabled) { 678 + if (!priv->dma_cap.eee) 679 + return -EOPNOTSUPP; 680 + 681 + if (priv->tx_lpi_enabled != edata->tx_lpi_enabled) 682 + netdev_warn(priv->dev, 683 + "Setting EEE tx-lpi is not supported\n"); 684 + 685 + if (!edata->eee_enabled) 680 686 stmmac_disable_eee_mode(priv); 681 - } else { 682 - /* We are asking for enabling the EEE but it is safe 683 - * to verify all by invoking the eee_init function. 684 - * In case of failure it will return an error. 685 - */ 686 - edata->eee_enabled = stmmac_eee_init(priv); 687 - if (!edata->eee_enabled) 688 - return -EOPNOTSUPP; 689 - } 690 687 691 688 ret = phylink_ethtool_set_eee(priv->phylink, edata); 692 689 if (ret) 693 690 return ret; 694 691 695 - priv->eee_enabled = edata->eee_enabled; 696 - priv->tx_lpi_timer = edata->tx_lpi_timer; 692 + if (edata->eee_enabled && 693 + priv->tx_lpi_timer != edata->tx_lpi_timer) { 694 + priv->tx_lpi_timer = edata->tx_lpi_timer; 695 + stmmac_eee_init(priv); 696 + } 697 + 697 698 return 0; 698 699 } 699 700

+15 -8

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

··· 94 94 static int eee_timer = STMMAC_DEFAULT_LPI_TIMER; 95 95 module_param(eee_timer, int, 0644); 96 96 MODULE_PARM_DESC(eee_timer, "LPI tx expiration time in msec"); 97 - #define STMMAC_LPI_T(x) (jiffies + msecs_to_jiffies(x)) 97 + #define STMMAC_LPI_T(x) (jiffies + usecs_to_jiffies(x)) 98 98 99 99 /* By default the driver will use the ring mode to manage tx and rx descriptors, 100 100 * but allow user to force to use the chain instead of the ring ··· 370 370 struct stmmac_priv *priv = from_timer(priv, t, eee_ctrl_timer); 371 371 372 372 stmmac_enable_eee_mode(priv); 373 - mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(eee_timer)); 373 + mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(priv->tx_lpi_timer)); 374 374 } 375 375 376 376 /** ··· 383 383 */ 384 384 bool stmmac_eee_init(struct stmmac_priv *priv) 385 385 { 386 - int tx_lpi_timer = priv->tx_lpi_timer; 386 + int eee_tw_timer = priv->eee_tw_timer; 387 387 388 388 /* Using PCS we cannot dial with the phy registers at this stage 389 389 * so we do not support extra feature like EEE. ··· 403 403 if (priv->eee_enabled) { 404 404 netdev_dbg(priv->dev, "disable EEE\n"); 405 405 del_timer_sync(&priv->eee_ctrl_timer); 406 - stmmac_set_eee_timer(priv, priv->hw, 0, tx_lpi_timer); 406 + stmmac_set_eee_timer(priv, priv->hw, 0, eee_tw_timer); 407 407 } 408 408 mutex_unlock(&priv->lock); 409 409 return false; ··· 411 411 412 412 if (priv->eee_active && !priv->eee_enabled) { 413 413 timer_setup(&priv->eee_ctrl_timer, stmmac_eee_ctrl_timer, 0); 414 - mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(eee_timer)); 415 414 stmmac_set_eee_timer(priv, priv->hw, STMMAC_DEFAULT_LIT_LS, 416 - tx_lpi_timer); 415 + eee_tw_timer); 417 416 } 417 + 418 + mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(priv->tx_lpi_timer)); 418 419 419 420 mutex_unlock(&priv->lock); 420 421 netdev_dbg(priv->dev, "Energy-Efficient Ethernet initialized\n"); ··· 931 930 932 931 stmmac_mac_set(priv, priv->ioaddr, false); 933 932 priv->eee_active = false; 933 + priv->tx_lpi_enabled = false; 934 934 stmmac_eee_init(priv); 935 935 stmmac_set_eee_pls(priv, priv->hw, false); 936 936 } ··· 1029 1027 if (phy && priv->dma_cap.eee) { 1030 1028 priv->eee_active = phy_init_eee(phy, 1) >= 0; 1031 1029 priv->eee_enabled = stmmac_eee_init(priv); 1030 + priv->tx_lpi_enabled = priv->eee_enabled; 1032 1031 stmmac_set_eee_pls(priv, priv->hw, true); 1033 1032 } 1034 1033 } ··· 2064 2061 2065 2062 if ((priv->eee_enabled) && (!priv->tx_path_in_lpi_mode)) { 2066 2063 stmmac_enable_eee_mode(priv); 2067 - mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(eee_timer)); 2064 + mod_timer(&priv->eee_ctrl_timer, STMMAC_LPI_T(priv->tx_lpi_timer)); 2068 2065 } 2069 2066 2070 2067 /* We still have pending packets, let's call for a new scheduling */ ··· 2697 2694 netdev_warn(priv->dev, "PTP init failed\n"); 2698 2695 } 2699 2696 2700 - priv->tx_lpi_timer = STMMAC_DEFAULT_TWT_LS; 2697 + priv->eee_tw_timer = STMMAC_DEFAULT_TWT_LS; 2698 + 2699 + /* Convert the timer from msec to usec */ 2700 + if (!priv->tx_lpi_timer) 2701 + priv->tx_lpi_timer = eee_timer * 1000; 2701 2702 2702 2703 if (priv->use_riwt) { 2703 2704 if (!priv->rx_riwt)

+4 -17

drivers/net/ethernet/via/via-rhine.c

··· 2 2 /* 3 3 Written 1998-2001 by Donald Becker. 4 4 5 - Current Maintainer: Roger Luethi <rl@hellgate.ch> 5 + Current Maintainer: Kevin Brace <kevinbrace@bracecomputerlab.com> 6 6 7 7 This software may be used and distributed according to the terms of 8 8 the GNU General Public License (GPL), incorporated herein by reference. ··· 32 32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 33 33 34 34 #define DRV_NAME "via-rhine" 35 - #define DRV_VERSION "1.5.1" 36 - #define DRV_RELDATE "2010-10-09" 37 35 38 36 #include <linux/types.h> 39 37 ··· 114 116 #include <asm/irq.h> 115 117 #include <linux/uaccess.h> 116 118 #include <linux/dmi.h> 117 - 118 - /* These identify the driver base version and may not be removed. */ 119 - static const char version[] = 120 - "v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker"; 121 119 122 120 MODULE_AUTHOR("Donald Becker <becker@scyld.com>"); 123 121 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver"); ··· 237 243 VT8233 = 0x60, /* Integrated MAC */ 238 244 VT8235 = 0x74, /* Integrated MAC */ 239 245 VT8237 = 0x78, /* Integrated MAC */ 240 - VTunknown1 = 0x7C, 246 + VT8251 = 0x7C, /* Integrated MAC */ 241 247 VT6105 = 0x80, 242 248 VT6105_B0 = 0x83, 243 249 VT6105L = 0x8A, ··· 1045 1051 u32 quirks = 0; 1046 1052 #endif 1047 1053 1048 - /* when built into the kernel, we only print version if device is found */ 1049 - #ifndef MODULE 1050 - pr_info_once("%s\n", version); 1051 - #endif 1052 - 1053 1054 rc = pci_enable_device(pdev); 1054 1055 if (rc) 1055 1056 goto err_out; ··· 1695 1706 goto out_free_ring; 1696 1707 1697 1708 alloc_tbufs(dev); 1709 + enable_mmio(rp->pioaddr, rp->quirks); 1710 + rhine_power_init(dev); 1698 1711 rhine_chip_reset(dev); 1699 1712 rhine_task_enable(rp); 1700 1713 init_registers(dev); ··· 2285 2294 struct device *hwdev = dev->dev.parent; 2286 2295 2287 2296 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 2288 - strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 2289 2297 strlcpy(info->bus_info, dev_name(hwdev), sizeof(info->bus_info)); 2290 2298 } 2291 2299 ··· 2606 2616 int ret_pci, ret_platform; 2607 2617 2608 2618 /* when a module, this is printed whether or not devices are found in probe */ 2609 - #ifdef MODULE 2610 - pr_info("%s\n", version); 2611 - #endif 2612 2619 if (dmi_check_system(rhine_dmi_table)) { 2613 2620 /* these BIOSes fail at PXE boot if chip is in D3 */ 2614 2621 avoid_D3 = true;

+1

drivers/net/phy/Kconfig

··· 222 222 depends on 64BIT 223 223 depends on PCI 224 224 select MDIO_CAVIUM 225 + select MDIO_DEVRES 225 226 help 226 227 This driver supports the MDIO interfaces found on Cavium 227 228 ThunderX SoCs when the MDIO bus device appears as a PCI

+16 -15

drivers/net/phy/realtek.c

··· 1 1 // SPDX-License-Identifier: GPL-2.0+ 2 - /* 3 - * drivers/net/phy/realtek.c 2 + /* drivers/net/phy/realtek.c 4 3 * 5 4 * Driver for Realtek PHYs 6 5 * ··· 31 32 #define RTL8211F_TX_DELAY BIT(8) 32 33 #define RTL8211F_RX_DELAY BIT(3) 33 34 34 - #define RTL8211E_TX_DELAY BIT(1) 35 - #define RTL8211E_RX_DELAY BIT(2) 36 - #define RTL8211E_MODE_MII_GMII BIT(3) 35 + #define RTL8211E_CTRL_DELAY BIT(13) 36 + #define RTL8211E_TX_DELAY BIT(12) 37 + #define RTL8211E_RX_DELAY BIT(11) 37 38 38 39 #define RTL8201F_ISR 0x1e 39 40 #define RTL8201F_IER 0x13 ··· 245 246 /* enable TX/RX delay for rgmii-* modes, and disable them for rgmii. */ 246 247 switch (phydev->interface) { 247 248 case PHY_INTERFACE_MODE_RGMII: 248 - val = 0; 249 + val = RTL8211E_CTRL_DELAY | 0; 249 250 break; 250 251 case PHY_INTERFACE_MODE_RGMII_ID: 251 - val = RTL8211E_TX_DELAY | RTL8211E_RX_DELAY; 252 + val = RTL8211E_CTRL_DELAY | RTL8211E_TX_DELAY | RTL8211E_RX_DELAY; 252 253 break; 253 254 case PHY_INTERFACE_MODE_RGMII_RXID: 254 - val = RTL8211E_RX_DELAY; 255 + val = RTL8211E_CTRL_DELAY | RTL8211E_RX_DELAY; 255 256 break; 256 257 case PHY_INTERFACE_MODE_RGMII_TXID: 257 - val = RTL8211E_TX_DELAY; 258 + val = RTL8211E_CTRL_DELAY | RTL8211E_TX_DELAY; 258 259 break; 259 260 default: /* the rest of the modes imply leaving delays as is. */ 260 261 return 0; ··· 262 263 263 264 /* According to a sample driver there is a 0x1c config register on the 264 265 * 0xa4 extension page (0x7) layout. It can be used to disable/enable 265 - * the RX/TX delays otherwise controlled by RXDLY/TXDLY pins. It can 266 - * also be used to customize the whole configuration register: 267 - * 8:6 = PHY Address, 5:4 = Auto-Negotiation, 3 = Interface Mode Select, 268 - * 2 = RX Delay, 1 = TX Delay, 0 = SELRGV (see original PHY datasheet 269 - * for details). 266 + * the RX/TX delays otherwise controlled by RXDLY/TXDLY pins. 267 + * The configuration register definition: 268 + * 14 = reserved 269 + * 13 = Force Tx RX Delay controlled by bit12 bit11, 270 + * 12 = RX Delay, 11 = TX Delay 271 + * 10:0 = Test && debug settings reserved by realtek 270 272 */ 271 273 oldpage = phy_select_page(phydev, 0x7); 272 274 if (oldpage < 0) ··· 277 277 if (ret) 278 278 goto err_restore_page; 279 279 280 - ret = __phy_modify(phydev, 0x1c, RTL8211E_TX_DELAY | RTL8211E_RX_DELAY, 280 + ret = __phy_modify(phydev, 0x1c, RTL8211E_CTRL_DELAY 281 + | RTL8211E_TX_DELAY | RTL8211E_RX_DELAY, 281 282 val); 282 283 283 284 err_restore_page:

+2 -1

drivers/net/team/team.c

··· 287 287 for (i--; i >= 0; i--) 288 288 __team_option_inst_del_option(team, dst_opts[i]); 289 289 290 - i = option_count - 1; 290 + i = option_count; 291 291 alloc_rollback: 292 292 for (i--; i >= 0; i--) 293 293 kfree(dst_opts[i]); ··· 2112 2112 dev->header_ops = port_dev->header_ops; 2113 2113 dev->type = port_dev->type; 2114 2114 dev->hard_header_len = port_dev->hard_header_len; 2115 + dev->needed_headroom = port_dev->needed_headroom; 2115 2116 dev->addr_len = port_dev->addr_len; 2116 2117 dev->mtu = port_dev->mtu; 2117 2118 memcpy(dev->broadcast, port_dev->broadcast, port_dev->addr_len);

+35

drivers/net/usb/ax88179_178a.c

··· 1823 1823 .status = ax88179_status, 1824 1824 .link_reset = ax88179_link_reset, 1825 1825 .reset = ax88179_reset, 1826 + .stop = ax88179_stop, 1827 + .flags = FLAG_ETHER | FLAG_FRAMING_AX, 1828 + .rx_fixup = ax88179_rx_fixup, 1829 + .tx_fixup = ax88179_tx_fixup, 1830 + }; 1831 + 1832 + static const struct driver_info toshiba_info = { 1833 + .description = "Toshiba USB Ethernet Adapter", 1834 + .bind = ax88179_bind, 1835 + .unbind = ax88179_unbind, 1836 + .status = ax88179_status, 1837 + .link_reset = ax88179_link_reset, 1838 + .reset = ax88179_reset, 1839 + .stop = ax88179_stop, 1840 + .flags = FLAG_ETHER | FLAG_FRAMING_AX, 1841 + .rx_fixup = ax88179_rx_fixup, 1842 + .tx_fixup = ax88179_tx_fixup, 1843 + }; 1844 + 1845 + static const struct driver_info mct_info = { 1846 + .description = "MCT USB 3.0 Gigabit Ethernet Adapter", 1847 + .bind = ax88179_bind, 1848 + .unbind = ax88179_unbind, 1849 + .status = ax88179_status, 1850 + .link_reset = ax88179_link_reset, 1851 + .reset = ax88179_reset, 1852 + .stop = ax88179_stop, 1826 1853 .flags = FLAG_ETHER | FLAG_FRAMING_AX, 1827 1854 .rx_fixup = ax88179_rx_fixup, 1828 1855 .tx_fixup = ax88179_tx_fixup, ··· 1888 1861 /* Belkin B2B128 USB 3.0 Hub + Gigabit Ethernet Adapter */ 1889 1862 USB_DEVICE(0x050d, 0x0128), 1890 1863 .driver_info = (unsigned long)&belkin_info, 1864 + }, { 1865 + /* Toshiba USB 3.0 GBit Ethernet Adapter */ 1866 + USB_DEVICE(0x0930, 0x0a13), 1867 + .driver_info = (unsigned long)&toshiba_info, 1868 + }, { 1869 + /* Magic Control Technology U3-A9003 USB 3.0 Gigabit Ethernet Adapter */ 1870 + USB_DEVICE(0x0711, 0x0179), 1871 + .driver_info = (unsigned long)&mct_info, 1891 1872 }, 1892 1873 { }, 1893 1874 };

+27 -8

drivers/net/usb/pegasus.c

··· 360 360 } 361 361 #endif /* PEGASUS_WRITE_EEPROM */ 362 362 363 - static inline void get_node_id(pegasus_t *pegasus, __u8 *id) 363 + static inline int get_node_id(pegasus_t *pegasus, u8 *id) 364 364 { 365 - int i; 366 - __u16 w16; 365 + int i, ret; 366 + u16 w16; 367 367 368 368 for (i = 0; i < 3; i++) { 369 - read_eprom_word(pegasus, i, &w16); 369 + ret = read_eprom_word(pegasus, i, &w16); 370 + if (ret < 0) 371 + return ret; 370 372 ((__le16 *) id)[i] = cpu_to_le16(w16); 371 373 } 374 + 375 + return 0; 372 376 } 373 377 374 378 static void set_ethernet_addr(pegasus_t *pegasus) 375 379 { 376 - __u8 node_id[6]; 380 + int ret; 381 + u8 node_id[6]; 377 382 378 383 if (pegasus->features & PEGASUS_II) { 379 - get_registers(pegasus, 0x10, sizeof(node_id), node_id); 384 + ret = get_registers(pegasus, 0x10, sizeof(node_id), node_id); 385 + if (ret < 0) 386 + goto err; 380 387 } else { 381 - get_node_id(pegasus, node_id); 382 - set_registers(pegasus, EthID, sizeof(node_id), node_id); 388 + ret = get_node_id(pegasus, node_id); 389 + if (ret < 0) 390 + goto err; 391 + ret = set_registers(pegasus, EthID, sizeof(node_id), node_id); 392 + if (ret < 0) 393 + goto err; 383 394 } 395 + 384 396 memcpy(pegasus->net->dev_addr, node_id, sizeof(node_id)); 397 + 398 + return; 399 + err: 400 + eth_hw_addr_random(pegasus->net); 401 + dev_info(&pegasus->intf->dev, "software assigned MAC address.\n"); 402 + 403 + return; 385 404 } 386 405 387 406 static inline int reset_mac(pegasus_t *pegasus)

+7 -1

drivers/net/virtio_net.c

··· 63 63 VIRTIO_NET_F_GUEST_CSUM 64 64 }; 65 65 66 + #define GUEST_OFFLOAD_LRO_MASK ((1ULL << VIRTIO_NET_F_GUEST_TSO4) | \ 67 + (1ULL << VIRTIO_NET_F_GUEST_TSO6) | \ 68 + (1ULL << VIRTIO_NET_F_GUEST_ECN) | \ 69 + (1ULL << VIRTIO_NET_F_GUEST_UFO)) 70 + 66 71 struct virtnet_stat_desc { 67 72 char desc[ETH_GSTRING_LEN]; 68 73 size_t offset; ··· 2536 2531 if (features & NETIF_F_LRO) 2537 2532 offloads = vi->guest_offloads_capable; 2538 2533 else 2539 - offloads = 0; 2534 + offloads = vi->guest_offloads_capable & 2535 + ~GUEST_OFFLOAD_LRO_MASK; 2540 2536 2541 2537 err = virtnet_set_guest_offloads(vi, offloads); 2542 2538 if (err)

+2 -3

drivers/net/vmxnet3/vmxnet3_drv.c

··· 1032 1032 /* Use temporary descriptor to avoid touching bits multiple times */ 1033 1033 union Vmxnet3_GenericDesc tempTxDesc; 1034 1034 #endif 1035 - struct udphdr *udph; 1036 1035 1037 1036 count = txd_estimate(skb); 1038 1037 ··· 1134 1135 gdesc->txd.om = VMXNET3_OM_ENCAP; 1135 1136 gdesc->txd.msscof = ctx.mss; 1136 1137 1137 - udph = udp_hdr(skb); 1138 - if (udph->check) 1138 + if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP_TUNNEL_CSUM) 1139 1139 gdesc->txd.oco = 1; 1140 1140 } else { 1141 1141 gdesc->txd.hlen = ctx.l4_offset + ctx.l4_hdr_size; ··· 3369 3371 .ndo_change_mtu = vmxnet3_change_mtu, 3370 3372 .ndo_fix_features = vmxnet3_fix_features, 3371 3373 .ndo_set_features = vmxnet3_set_features, 3374 + .ndo_features_check = vmxnet3_features_check, 3372 3375 .ndo_get_stats64 = vmxnet3_get_stats64, 3373 3376 .ndo_tx_timeout = vmxnet3_tx_timeout, 3374 3377 .ndo_set_rx_mode = vmxnet3_set_mc,

+28

drivers/net/vmxnet3/vmxnet3_ethtool.c

··· 267 267 return features; 268 268 } 269 269 270 + netdev_features_t vmxnet3_features_check(struct sk_buff *skb, 271 + struct net_device *netdev, 272 + netdev_features_t features) 273 + { 274 + struct vmxnet3_adapter *adapter = netdev_priv(netdev); 275 + 276 + /* Validate if the tunneled packet is being offloaded by the device */ 277 + if (VMXNET3_VERSION_GE_4(adapter) && 278 + skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL) { 279 + u8 l4_proto = 0; 280 + 281 + switch (vlan_get_protocol(skb)) { 282 + case htons(ETH_P_IP): 283 + l4_proto = ip_hdr(skb)->protocol; 284 + break; 285 + case htons(ETH_P_IPV6): 286 + l4_proto = ipv6_hdr(skb)->nexthdr; 287 + break; 288 + default: 289 + return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 290 + } 291 + 292 + if (l4_proto != IPPROTO_UDP) 293 + return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK); 294 + } 295 + return features; 296 + } 297 + 270 298 static void vmxnet3_enable_encap_offloads(struct net_device *netdev) 271 299 { 272 300 struct vmxnet3_adapter *adapter = netdev_priv(netdev);

+4

drivers/net/vmxnet3/vmxnet3_int.h

··· 470 470 netdev_features_t 471 471 vmxnet3_fix_features(struct net_device *netdev, netdev_features_t features); 472 472 473 + netdev_features_t 474 + vmxnet3_features_check(struct sk_buff *skb, 475 + struct net_device *netdev, netdev_features_t features); 476 + 473 477 int 474 478 vmxnet3_set_features(struct net_device *netdev, netdev_features_t features); 475 479

+26 -17

drivers/net/wan/x25_asy.c

··· 464 464 { 465 465 struct x25_asy *sl = netdev_priv(dev); 466 466 unsigned long len; 467 - int err; 468 467 469 468 if (sl->tty == NULL) 470 469 return -ENODEV; ··· 489 490 sl->xleft = 0; 490 491 sl->flags &= (1 << SLF_INUSE); /* Clear ESCAPE & ERROR flags */ 491 492 492 - netif_start_queue(dev); 493 - 494 - /* 495 - * Now attach LAPB 496 - */ 497 - err = lapb_register(dev, &x25_asy_callbacks); 498 - if (err == LAPB_OK) 499 - return 0; 493 + return 0; 500 494 501 495 /* Cleanup */ 502 496 kfree(sl->xbuff); ··· 511 519 if (sl->tty) 512 520 clear_bit(TTY_DO_WRITE_WAKEUP, &sl->tty->flags); 513 521 514 - netif_stop_queue(dev); 515 522 sl->rcount = 0; 516 523 sl->xleft = 0; 517 524 spin_unlock(&sl->lock); ··· 595 604 static void x25_asy_close_tty(struct tty_struct *tty) 596 605 { 597 606 struct x25_asy *sl = tty->disc_data; 598 - int err; 599 607 600 608 /* First make sure we're connected. */ 601 609 if (!sl || sl->magic != X25_ASY_MAGIC) ··· 604 614 if (sl->dev->flags & IFF_UP) 605 615 dev_close(sl->dev); 606 616 rtnl_unlock(); 607 - 608 - err = lapb_unregister(sl->dev); 609 - if (err != LAPB_OK) 610 - pr_err("%s: lapb_unregister error: %d\n", 611 - __func__, err); 612 617 613 618 tty->disc_data = NULL; 614 619 sl->tty = NULL; ··· 707 722 708 723 static int x25_asy_open_dev(struct net_device *dev) 709 724 { 725 + int err; 710 726 struct x25_asy *sl = netdev_priv(dev); 711 727 if (sl->tty == NULL) 712 728 return -ENODEV; 729 + 730 + err = lapb_register(dev, &x25_asy_callbacks); 731 + if (err != LAPB_OK) 732 + return -ENOMEM; 733 + 734 + netif_start_queue(dev); 735 + 736 + return 0; 737 + } 738 + 739 + static int x25_asy_close_dev(struct net_device *dev) 740 + { 741 + int err; 742 + 743 + netif_stop_queue(dev); 744 + 745 + err = lapb_unregister(dev); 746 + if (err != LAPB_OK) 747 + pr_err("%s: lapb_unregister error: %d\n", 748 + __func__, err); 749 + 750 + x25_asy_close(dev); 751 + 713 752 return 0; 714 753 } 715 754 716 755 static const struct net_device_ops x25_asy_netdev_ops = { 717 756 .ndo_open = x25_asy_open_dev, 718 - .ndo_stop = x25_asy_close, 757 + .ndo_stop = x25_asy_close_dev, 719 758 .ndo_start_xmit = x25_asy_xmit, 720 759 .ndo_tx_timeout = x25_asy_timeout, 721 760 .ndo_change_mtu = x25_asy_change_mtu,

+1 -1

drivers/net/wireless/mediatek/mt76/mt7615/init.c

··· 460 460 dev->mphy.sband_2g.sband.ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 461 461 dev->mphy.sband_5g.sband.ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 462 462 dev->mphy.sband_5g.sband.vht_cap.cap |= 463 - IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 | 463 + IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991 | 464 464 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK; 465 465 mt7615_cap_dbdc_disable(dev); 466 466 dev->phy.dfs_state = -1;

+7 -3

drivers/net/wireless/quantenna/qtnfmac/core.c

··· 671 671 return ndev->netdev_ops == &qtnf_netdev_ops; 672 672 } 673 673 674 - static int qtnf_check_br_ports(struct net_device *dev, void *data) 674 + static int qtnf_check_br_ports(struct net_device *dev, 675 + struct netdev_nested_priv *priv) 675 676 { 676 - struct net_device *ndev = data; 677 + struct net_device *ndev = (struct net_device *)priv->data; 677 678 678 679 if (dev != ndev && netdev_port_same_parent_id(dev, ndev)) 679 680 return -ENOTSUPP; ··· 687 686 { 688 687 struct net_device *ndev = netdev_notifier_info_to_dev(ptr); 689 688 const struct netdev_notifier_changeupper_info *info; 689 + struct netdev_nested_priv priv = { 690 + .data = (void *)ndev, 691 + }; 690 692 struct net_device *brdev; 691 693 struct qtnf_vif *vif; 692 694 struct qtnf_bus *bus; ··· 729 725 } else { 730 726 ret = netdev_walk_all_lower_dev(brdev, 731 727 qtnf_check_br_ports, 732 - ndev); 728 + &priv); 733 729 } 734 730 735 731 break;

+3 -4

drivers/nvme/host/tcp.c

··· 913 913 else 914 914 flags |= MSG_MORE | MSG_SENDPAGE_NOTLAST; 915 915 916 - /* can't zcopy slab pages */ 917 - if (unlikely(PageSlab(page))) { 918 - ret = sock_no_sendpage(queue->sock, page, offset, len, 916 + if (sendpage_ok(page)) { 917 + ret = kernel_sendpage(queue->sock, page, offset, len, 919 918 flags); 920 919 } else { 921 - ret = kernel_sendpage(queue->sock, page, offset, len, 920 + ret = sock_no_sendpage(queue->sock, page, offset, len, 922 921 flags); 923 922 } 924 923 if (ret <= 0)

+1 -1

drivers/scsi/libiscsi_tcp.c

··· 128 128 * coalescing neighboring slab objects into a single frag which 129 129 * triggers one of hardened usercopy checks. 130 130 */ 131 - if (!recv && page_count(sg_page(sg)) >= 1 && !PageSlab(sg_page(sg))) 131 + if (!recv && sendpage_ok(sg_page(sg))) 132 132 return; 133 133 134 134 if (recv) {

+1 -1

include/asm-generic/vmlinux.lds.h

··· 661 661 #define BTF \ 662 662 .BTF : AT(ADDR(.BTF) - LOAD_OFFSET) { \ 663 663 __start_BTF = .; \ 664 - *(.BTF) \ 664 + KEEP(*(.BTF)) \ 665 665 __stop_BTF = .; \ 666 666 } \ 667 667 . = ALIGN(4); \

+3

include/linux/mlx5/driver.h

··· 767 767 u64 ts2; 768 768 u16 op; 769 769 bool polling; 770 + /* Track the max comp handlers */ 771 + refcount_t refcnt; 770 772 }; 771 773 772 774 struct mlx5_pas { ··· 935 933 int mlx5_cmd_exec_polling(struct mlx5_core_dev *dev, void *in, int in_size, 936 934 void *out, int out_size); 937 935 void mlx5_cmd_mbox_status(void *out, u8 *status, u32 *syndrome); 936 + bool mlx5_cmd_is_down(struct mlx5_core_dev *dev); 938 937 939 938 int mlx5_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type); 940 939 int mlx5_cmd_alloc_uar(struct mlx5_core_dev *dev, u32 *uarn);

+16

include/linux/net.h

··· 21 21 #include <linux/rcupdate.h> 22 22 #include <linux/once.h> 23 23 #include <linux/fs.h> 24 + #include <linux/mm.h> 24 25 #include <linux/sockptr.h> 25 26 26 27 #include <uapi/linux/net.h> ··· 286 285 get_random_once((buf), (nbytes)) 287 286 #define net_get_random_once_wait(buf, nbytes) \ 288 287 get_random_once_wait((buf), (nbytes)) 288 + 289 + /* 290 + * E.g. XFS meta- & log-data is in slab pages, or bcache meta 291 + * data pages, or other high order pages allocated by 292 + * __get_free_pages() without __GFP_COMP, which have a page_count 293 + * of 0 and/or have PageSlab() set. We cannot use send_page for 294 + * those, as that does get_page(); put_page(); and would cause 295 + * either a VM_BUG directly, or __page_cache_release a page that 296 + * would actually still be referenced by someone, leading to some 297 + * obscure delayed Oops somewhere else. 298 + */ 299 + static inline bool sendpage_ok(struct page *page) 300 + { 301 + return !PageSlab(page) && page_count(page) >= 1; 302 + } 289 303 290 304 int kernel_sendmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec, 291 305 size_t num, size_t len);

+59 -14

include/linux/netdevice.h

··· 1851 1851 * @udp_tunnel_nic: UDP tunnel offload state 1852 1852 * @xdp_state: stores info on attached XDP BPF programs 1853 1853 * 1854 + * @nested_level: Used as as a parameter of spin_lock_nested() of 1855 + * dev->addr_list_lock. 1856 + * @unlink_list: As netif_addr_lock() can be called recursively, 1857 + * keep a list of interfaces to be deleted. 1858 + * 1854 1859 * FIXME: cleanup struct net_device such that network protocol info 1855 1860 * moves out. 1856 1861 */ ··· 1960 1955 unsigned short type; 1961 1956 unsigned short hard_header_len; 1962 1957 unsigned char min_header_len; 1958 + unsigned char name_assign_type; 1963 1959 1964 1960 unsigned short needed_headroom; 1965 1961 unsigned short needed_tailroom; ··· 1971 1965 unsigned char addr_len; 1972 1966 unsigned char upper_level; 1973 1967 unsigned char lower_level; 1968 + 1974 1969 unsigned short neigh_priv_len; 1975 1970 unsigned short dev_id; 1976 1971 unsigned short dev_port; 1977 1972 spinlock_t addr_list_lock; 1978 - unsigned char name_assign_type; 1979 - bool uc_promisc; 1973 + 1980 1974 struct netdev_hw_addr_list uc; 1981 1975 struct netdev_hw_addr_list mc; 1982 1976 struct netdev_hw_addr_list dev_addrs; ··· 1984 1978 #ifdef CONFIG_SYSFS 1985 1979 struct kset *queues_kset; 1986 1980 #endif 1981 + #ifdef CONFIG_LOCKDEP 1982 + struct list_head unlink_list; 1983 + #endif 1987 1984 unsigned int promiscuity; 1988 1985 unsigned int allmulti; 1986 + bool uc_promisc; 1987 + #ifdef CONFIG_LOCKDEP 1988 + unsigned char nested_level; 1989 + #endif 1989 1990 1990 1991 1991 1992 /* Protocol-specific pointers */ ··· 4273 4260 4274 4261 static inline void netif_addr_lock(struct net_device *dev) 4275 4262 { 4276 - spin_lock(&dev->addr_list_lock); 4277 - } 4263 + unsigned char nest_level = 0; 4278 4264 4279 - static inline void netif_addr_lock_nested(struct net_device *dev) 4280 - { 4281 - spin_lock_nested(&dev->addr_list_lock, dev->lower_level); 4265 + #ifdef CONFIG_LOCKDEP 4266 + nest_level = dev->nested_level; 4267 + #endif 4268 + spin_lock_nested(&dev->addr_list_lock, nest_level); 4282 4269 } 4283 4270 4284 4271 static inline void netif_addr_lock_bh(struct net_device *dev) 4285 4272 { 4286 - spin_lock_bh(&dev->addr_list_lock); 4273 + unsigned char nest_level = 0; 4274 + 4275 + #ifdef CONFIG_LOCKDEP 4276 + nest_level = dev->nested_level; 4277 + #endif 4278 + local_bh_disable(); 4279 + spin_lock_nested(&dev->addr_list_lock, nest_level); 4287 4280 } 4288 4281 4289 4282 static inline void netif_addr_unlock(struct net_device *dev) ··· 4474 4455 extern int dev_tx_weight; 4475 4456 extern int gro_normal_batch; 4476 4457 4458 + enum { 4459 + NESTED_SYNC_IMM_BIT, 4460 + NESTED_SYNC_TODO_BIT, 4461 + }; 4462 + 4463 + #define __NESTED_SYNC_BIT(bit) ((u32)1 << (bit)) 4464 + #define __NESTED_SYNC(name) __NESTED_SYNC_BIT(NESTED_SYNC_ ## name ## _BIT) 4465 + 4466 + #define NESTED_SYNC_IMM __NESTED_SYNC(IMM) 4467 + #define NESTED_SYNC_TODO __NESTED_SYNC(TODO) 4468 + 4469 + struct netdev_nested_priv { 4470 + unsigned char flags; 4471 + void *data; 4472 + }; 4473 + 4477 4474 bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev); 4478 4475 struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev, 4479 4476 struct list_head **iter); 4480 4477 struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev, 4481 4478 struct list_head **iter); 4479 + 4480 + #ifdef CONFIG_LOCKDEP 4481 + static LIST_HEAD(net_unlink_list); 4482 + 4483 + static inline void net_unlink_todo(struct net_device *dev) 4484 + { 4485 + if (list_empty(&dev->unlink_list)) 4486 + list_add_tail(&dev->unlink_list, &net_unlink_list); 4487 + } 4488 + #endif 4482 4489 4483 4490 /* iterate through upper list, must be called under RCU read lock */ 4484 4491 #define netdev_for_each_upper_dev_rcu(dev, updev, iter) \ ··· 4515 4470 4516 4471 int netdev_walk_all_upper_dev_rcu(struct net_device *dev, 4517 4472 int (*fn)(struct net_device *upper_dev, 4518 - void *data), 4519 - void *data); 4473 + struct netdev_nested_priv *priv), 4474 + struct netdev_nested_priv *priv); 4520 4475 4521 4476 bool netdev_has_upper_dev_all_rcu(struct net_device *dev, 4522 4477 struct net_device *upper_dev); ··· 4553 4508 struct list_head **iter); 4554 4509 int netdev_walk_all_lower_dev(struct net_device *dev, 4555 4510 int (*fn)(struct net_device *lower_dev, 4556 - void *data), 4557 - void *data); 4511 + struct netdev_nested_priv *priv), 4512 + struct netdev_nested_priv *priv); 4558 4513 int netdev_walk_all_lower_dev_rcu(struct net_device *dev, 4559 4514 int (*fn)(struct net_device *lower_dev, 4560 - void *data), 4561 - void *data); 4515 + struct netdev_nested_priv *priv), 4516 + struct netdev_nested_priv *priv); 4562 4517 4563 4518 void *netdev_adjacent_get_private(struct list_head *adj_list); 4564 4519 void *netdev_lower_get_first_private_rcu(struct net_device *dev);

-2

include/net/act_api.h

··· 166 166 struct nlattr *est, struct tc_action **a, 167 167 const struct tc_action_ops *ops, int bind, 168 168 u32 flags); 169 - void tcf_idr_insert(struct tc_action_net *tn, struct tc_action *a); 170 - 171 169 void tcf_idr_cleanup(struct tc_action_net *tn, u32 index); 172 170 int tcf_idr_check_alloc(struct tc_action_net *tn, u32 *index, 173 171 struct tc_action **a, int bind);

+1

include/net/genetlink.h

··· 138 138 * @cmd: command identifier 139 139 * @internal_flags: flags used by the family 140 140 * @flags: flags 141 + * @validate: validation flags from enum genl_validate_flags 141 142 * @doit: standard command callback 142 143 * @start: start callback for dumps 143 144 * @dumpit: callback for dumpers

+6

include/net/ip.h

··· 436 436 bool forwarding) 437 437 { 438 438 struct net *net = dev_net(dst->dev); 439 + unsigned int mtu; 439 440 440 441 if (net->ipv4.sysctl_ip_fwd_use_pmtu || 441 442 ip_mtu_locked(dst) || 442 443 !forwarding) 443 444 return dst_mtu(dst); 445 + 446 + /* 'forwarding = true' case should always honour route mtu */ 447 + mtu = dst_metric_raw(dst, RTAX_MTU); 448 + if (mtu) 449 + return mtu; 444 450 445 451 return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU); 446 452 }

+2 -1

include/net/netlink.h

··· 1934 1934 int netlink_policy_dump_start(const struct nla_policy *policy, 1935 1935 unsigned int maxtype, 1936 1936 unsigned long *state); 1937 - bool netlink_policy_dump_loop(unsigned long *state); 1937 + bool netlink_policy_dump_loop(unsigned long state); 1938 1938 int netlink_policy_dump_write(struct sk_buff *skb, unsigned long state); 1939 + void netlink_policy_dump_free(unsigned long state); 1939 1940 1940 1941 #endif

+6 -10

include/net/xfrm.h

··· 1773 1773 static inline int xfrm_replay_clone(struct xfrm_state *x, 1774 1774 struct xfrm_state *orig) 1775 1775 { 1776 - x->replay_esn = kzalloc(xfrm_replay_state_esn_len(orig->replay_esn), 1776 + 1777 + x->replay_esn = kmemdup(orig->replay_esn, 1778 + xfrm_replay_state_esn_len(orig->replay_esn), 1777 1779 GFP_KERNEL); 1778 1780 if (!x->replay_esn) 1779 1781 return -ENOMEM; 1780 - 1781 - x->replay_esn->bmp_len = orig->replay_esn->bmp_len; 1782 - x->replay_esn->replay_window = orig->replay_esn->replay_window; 1783 - 1784 - x->preplay_esn = kmemdup(x->replay_esn, 1785 - xfrm_replay_state_esn_len(x->replay_esn), 1782 + x->preplay_esn = kmemdup(orig->preplay_esn, 1783 + xfrm_replay_state_esn_len(orig->preplay_esn), 1786 1784 GFP_KERNEL); 1787 - if (!x->preplay_esn) { 1788 - kfree(x->replay_esn); 1785 + if (!x->preplay_esn) 1789 1786 return -ENOMEM; 1790 - } 1791 1787 1792 1788 return 0; 1793 1789 }

+4 -4

include/soc/mscc/ocelot_ana.h

··· 252 252 #define ANA_SG_CONFIG_REG_3_LIST_LENGTH_M GENMASK(18, 16) 253 253 #define ANA_SG_CONFIG_REG_3_LIST_LENGTH_X(x) (((x) & GENMASK(18, 16)) >> 16) 254 254 #define ANA_SG_CONFIG_REG_3_GATE_ENABLE BIT(20) 255 - #define ANA_SG_CONFIG_REG_3_INIT_IPS(x) (((x) << 24) & GENMASK(27, 24)) 256 - #define ANA_SG_CONFIG_REG_3_INIT_IPS_M GENMASK(27, 24) 257 - #define ANA_SG_CONFIG_REG_3_INIT_IPS_X(x) (((x) & GENMASK(27, 24)) >> 24) 258 - #define ANA_SG_CONFIG_REG_3_INIT_GATE_STATE BIT(28) 255 + #define ANA_SG_CONFIG_REG_3_INIT_IPS(x) (((x) << 21) & GENMASK(24, 21)) 256 + #define ANA_SG_CONFIG_REG_3_INIT_IPS_M GENMASK(24, 21) 257 + #define ANA_SG_CONFIG_REG_3_INIT_IPS_X(x) (((x) & GENMASK(24, 21)) >> 21) 258 + #define ANA_SG_CONFIG_REG_3_INIT_GATE_STATE BIT(25) 259 259 260 260 #define ANA_SG_GCL_GS_CONFIG_RSZ 0x4 261 261

+1

include/uapi/linux/snmp.h

··· 288 288 LINUX_MIB_TCPTIMEOUTREHASH, /* TCPTimeoutRehash */ 289 289 LINUX_MIB_TCPDUPLICATEDATAREHASH, /* TCPDuplicateDataRehash */ 290 290 LINUX_MIB_TCPDSACKRECVSEGS, /* TCPDSACKRecvSegs */ 291 + LINUX_MIB_TCPDSACKIGNOREDDUBIOUS, /* TCPDSACKIgnoredDubious */ 291 292 __LINUX_MIB_MAX 292 293 }; 293 294

+3 -3

kernel/bpf/sysfs_btf.c

··· 30 30 31 31 static int __init btf_vmlinux_init(void) 32 32 { 33 - if (!__start_BTF) 33 + bin_attr_btf_vmlinux.size = __stop_BTF - __start_BTF; 34 + 35 + if (!__start_BTF || bin_attr_btf_vmlinux.size == 0) 34 36 return 0; 35 37 36 38 btf_kobj = kobject_create_and_add("btf", kernel_kobj); 37 39 if (!btf_kobj) 38 40 return -ENOMEM; 39 - 40 - bin_attr_btf_vmlinux.size = __stop_BTF - __start_BTF; 41 41 42 42 return sysfs_create_bin_file(btf_kobj, &bin_attr_btf_vmlinux); 43 43 }

+18 -8

net/bridge/br_arp_nd_proxy.c

··· 88 88 } 89 89 } 90 90 91 - static int br_chk_addr_ip(struct net_device *dev, void *data) 91 + static int br_chk_addr_ip(struct net_device *dev, 92 + struct netdev_nested_priv *priv) 92 93 { 93 - __be32 ip = *(__be32 *)data; 94 + __be32 ip = *(__be32 *)priv->data; 94 95 struct in_device *in_dev; 95 96 __be32 addr = 0; 96 97 ··· 108 107 109 108 static bool br_is_local_ip(struct net_device *dev, __be32 ip) 110 109 { 111 - if (br_chk_addr_ip(dev, &ip)) 110 + struct netdev_nested_priv priv = { 111 + .data = (void *)&ip, 112 + }; 113 + 114 + if (br_chk_addr_ip(dev, &priv)) 112 115 return true; 113 116 114 117 /* check if ip is configured on upper dev */ 115 - if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip, &ip)) 118 + if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip, &priv)) 116 119 return true; 117 120 118 121 return false; ··· 366 361 } 367 362 } 368 363 369 - static int br_chk_addr_ip6(struct net_device *dev, void *data) 364 + static int br_chk_addr_ip6(struct net_device *dev, 365 + struct netdev_nested_priv *priv) 370 366 { 371 - struct in6_addr *addr = (struct in6_addr *)data; 367 + struct in6_addr *addr = (struct in6_addr *)priv->data; 372 368 373 369 if (ipv6_chk_addr(dev_net(dev), addr, dev, 0)) 374 370 return 1; ··· 380 374 static bool br_is_local_ip6(struct net_device *dev, struct in6_addr *addr) 381 375 382 376 { 383 - if (br_chk_addr_ip6(dev, addr)) 377 + struct netdev_nested_priv priv = { 378 + .data = (void *)addr, 379 + }; 380 + 381 + if (br_chk_addr_ip6(dev, &priv)) 384 382 return true; 385 383 386 384 /* check if ip is configured on upper dev */ 387 - if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip6, addr)) 385 + if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip6, &priv)) 388 386 return true; 389 387 390 388 return false;

+2

net/bridge/br_fdb.c

··· 413 413 414 414 if (!do_all) 415 415 if (test_bit(BR_FDB_STATIC, &f->flags) || 416 + (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags) && 417 + !test_bit(BR_FDB_OFFLOADED, &f->flags)) || 416 418 (vid && f->key.vlan_id != vid)) 417 419 continue; 418 420

+13 -7

net/bridge/br_vlan.c

··· 1360 1360 } 1361 1361 1362 1362 static int br_vlan_is_bind_vlan_dev_fn(struct net_device *dev, 1363 - __always_unused void *data) 1363 + __always_unused struct netdev_nested_priv *priv) 1364 1364 { 1365 1365 return br_vlan_is_bind_vlan_dev(dev); 1366 1366 } ··· 1383 1383 }; 1384 1384 1385 1385 static int br_vlan_match_bind_vlan_dev_fn(struct net_device *dev, 1386 - void *data_in) 1386 + struct netdev_nested_priv *priv) 1387 1387 { 1388 - struct br_vlan_bind_walk_data *data = data_in; 1388 + struct br_vlan_bind_walk_data *data = priv->data; 1389 1389 int found = 0; 1390 1390 1391 1391 if (br_vlan_is_bind_vlan_dev(dev) && ··· 1403 1403 struct br_vlan_bind_walk_data data = { 1404 1404 .vid = vid, 1405 1405 }; 1406 + struct netdev_nested_priv priv = { 1407 + .data = (void *)&data, 1408 + }; 1406 1409 1407 1410 rcu_read_lock(); 1408 1411 netdev_walk_all_upper_dev_rcu(dev, br_vlan_match_bind_vlan_dev_fn, 1409 - &data); 1412 + &priv); 1410 1413 rcu_read_unlock(); 1411 1414 1412 1415 return data.result; ··· 1490 1487 }; 1491 1488 1492 1489 static int br_vlan_link_state_change_fn(struct net_device *vlan_dev, 1493 - void *data_in) 1490 + struct netdev_nested_priv *priv) 1494 1491 { 1495 - struct br_vlan_link_state_walk_data *data = data_in; 1492 + struct br_vlan_link_state_walk_data *data = priv->data; 1496 1493 1497 1494 if (br_vlan_is_bind_vlan_dev(vlan_dev)) 1498 1495 br_vlan_set_vlan_dev_state(data->br, vlan_dev); ··· 1506 1503 struct br_vlan_link_state_walk_data data = { 1507 1504 .br = br 1508 1505 }; 1506 + struct netdev_nested_priv priv = { 1507 + .data = (void *)&data, 1508 + }; 1509 1509 1510 1510 rcu_read_lock(); 1511 1511 netdev_walk_all_upper_dev_rcu(dev, br_vlan_link_state_change_fn, 1512 - &data); 1512 + &priv); 1513 1513 rcu_read_unlock(); 1514 1514 } 1515 1515

+1 -1

net/ceph/messenger.c

··· 575 575 * coalescing neighboring slab objects into a single frag which 576 576 * triggers one of hardened usercopy checks. 577 577 */ 578 - if (page_count(page) >= 1 && !PageSlab(page)) 578 + if (sendpage_ok(page)) 579 579 sendpage = sock->ops->sendpage; 580 580 else 581 581 sendpage = sock_no_sendpage;

+122 -42

net/core/dev.c

··· 6812 6812 return NULL; 6813 6813 } 6814 6814 6815 - static int ____netdev_has_upper_dev(struct net_device *upper_dev, void *data) 6815 + static int ____netdev_has_upper_dev(struct net_device *upper_dev, 6816 + struct netdev_nested_priv *priv) 6816 6817 { 6817 - struct net_device *dev = data; 6818 + struct net_device *dev = (struct net_device *)priv->data; 6818 6819 6819 6820 return upper_dev == dev; 6820 6821 } ··· 6832 6831 bool netdev_has_upper_dev(struct net_device *dev, 6833 6832 struct net_device *upper_dev) 6834 6833 { 6834 + struct netdev_nested_priv priv = { 6835 + .data = (void *)upper_dev, 6836 + }; 6837 + 6835 6838 ASSERT_RTNL(); 6836 6839 6837 6840 return netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev, 6838 - upper_dev); 6841 + &priv); 6839 6842 } 6840 6843 EXPORT_SYMBOL(netdev_has_upper_dev); 6841 6844 ··· 6856 6851 bool netdev_has_upper_dev_all_rcu(struct net_device *dev, 6857 6852 struct net_device *upper_dev) 6858 6853 { 6854 + struct netdev_nested_priv priv = { 6855 + .data = (void *)upper_dev, 6856 + }; 6857 + 6859 6858 return !!netdev_walk_all_upper_dev_rcu(dev, ____netdev_has_upper_dev, 6860 - upper_dev); 6859 + &priv); 6861 6860 } 6862 6861 EXPORT_SYMBOL(netdev_has_upper_dev_all_rcu); 6863 6862 ··· 7006 6997 7007 6998 static int __netdev_walk_all_upper_dev(struct net_device *dev, 7008 6999 int (*fn)(struct net_device *dev, 7009 - void *data), 7010 - void *data) 7000 + struct netdev_nested_priv *priv), 7001 + struct netdev_nested_priv *priv) 7011 7002 { 7012 7003 struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 7013 7004 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; ··· 7019 7010 7020 7011 while (1) { 7021 7012 if (now != dev) { 7022 - ret = fn(now, data); 7013 + ret = fn(now, priv); 7023 7014 if (ret) 7024 7015 return ret; 7025 7016 } ··· 7055 7046 7056 7047 int netdev_walk_all_upper_dev_rcu(struct net_device *dev, 7057 7048 int (*fn)(struct net_device *dev, 7058 - void *data), 7059 - void *data) 7049 + struct netdev_nested_priv *priv), 7050 + struct netdev_nested_priv *priv) 7060 7051 { 7061 7052 struct net_device *udev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 7062 7053 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; ··· 7067 7058 7068 7059 while (1) { 7069 7060 if (now != dev) { 7070 - ret = fn(now, data); 7061 + ret = fn(now, priv); 7071 7062 if (ret) 7072 7063 return ret; 7073 7064 } ··· 7103 7094 static bool __netdev_has_upper_dev(struct net_device *dev, 7104 7095 struct net_device *upper_dev) 7105 7096 { 7097 + struct netdev_nested_priv priv = { 7098 + .flags = 0, 7099 + .data = (void *)upper_dev, 7100 + }; 7101 + 7106 7102 ASSERT_RTNL(); 7107 7103 7108 7104 return __netdev_walk_all_upper_dev(dev, ____netdev_has_upper_dev, 7109 - upper_dev); 7105 + &priv); 7110 7106 } 7111 7107 7112 7108 /** ··· 7229 7215 7230 7216 int netdev_walk_all_lower_dev(struct net_device *dev, 7231 7217 int (*fn)(struct net_device *dev, 7232 - void *data), 7233 - void *data) 7218 + struct netdev_nested_priv *priv), 7219 + struct netdev_nested_priv *priv) 7234 7220 { 7235 7221 struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 7236 7222 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; ··· 7241 7227 7242 7228 while (1) { 7243 7229 if (now != dev) { 7244 - ret = fn(now, data); 7230 + ret = fn(now, priv); 7245 7231 if (ret) 7246 7232 return ret; 7247 7233 } ··· 7276 7262 7277 7263 static int __netdev_walk_all_lower_dev(struct net_device *dev, 7278 7264 int (*fn)(struct net_device *dev, 7279 - void *data), 7280 - void *data) 7265 + struct netdev_nested_priv *priv), 7266 + struct netdev_nested_priv *priv) 7281 7267 { 7282 7268 struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 7283 7269 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; ··· 7289 7275 7290 7276 while (1) { 7291 7277 if (now != dev) { 7292 - ret = fn(now, data); 7278 + ret = fn(now, priv); 7293 7279 if (ret) 7294 7280 return ret; 7295 7281 } ··· 7378 7364 return max_depth; 7379 7365 } 7380 7366 7381 - static int __netdev_update_upper_level(struct net_device *dev, void *data) 7367 + static int __netdev_update_upper_level(struct net_device *dev, 7368 + struct netdev_nested_priv *__unused) 7382 7369 { 7383 7370 dev->upper_level = __netdev_upper_depth(dev) + 1; 7384 7371 return 0; 7385 7372 } 7386 7373 7387 - static int __netdev_update_lower_level(struct net_device *dev, void *data) 7374 + static int __netdev_update_lower_level(struct net_device *dev, 7375 + struct netdev_nested_priv *priv) 7388 7376 { 7389 7377 dev->lower_level = __netdev_lower_depth(dev) + 1; 7378 + 7379 + #ifdef CONFIG_LOCKDEP 7380 + if (!priv) 7381 + return 0; 7382 + 7383 + if (priv->flags & NESTED_SYNC_IMM) 7384 + dev->nested_level = dev->lower_level - 1; 7385 + if (priv->flags & NESTED_SYNC_TODO) 7386 + net_unlink_todo(dev); 7387 + #endif 7390 7388 return 0; 7391 7389 } 7392 7390 7393 7391 int netdev_walk_all_lower_dev_rcu(struct net_device *dev, 7394 7392 int (*fn)(struct net_device *dev, 7395 - void *data), 7396 - void *data) 7393 + struct netdev_nested_priv *priv), 7394 + struct netdev_nested_priv *priv) 7397 7395 { 7398 7396 struct net_device *ldev, *next, *now, *dev_stack[MAX_NEST_DEV + 1]; 7399 7397 struct list_head *niter, *iter, *iter_stack[MAX_NEST_DEV + 1]; ··· 7416 7390 7417 7391 while (1) { 7418 7392 if (now != dev) { 7419 - ret = fn(now, data); 7393 + ret = fn(now, priv); 7420 7394 if (ret) 7421 7395 return ret; 7422 7396 } ··· 7676 7650 static int __netdev_upper_dev_link(struct net_device *dev, 7677 7651 struct net_device *upper_dev, bool master, 7678 7652 void *upper_priv, void *upper_info, 7653 + struct netdev_nested_priv *priv, 7679 7654 struct netlink_ext_ack *extack) 7680 7655 { 7681 7656 struct netdev_notifier_changeupper_info changeupper_info = { ··· 7733 7706 __netdev_update_upper_level(dev, NULL); 7734 7707 __netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL); 7735 7708 7736 - __netdev_update_lower_level(upper_dev, NULL); 7709 + __netdev_update_lower_level(upper_dev, priv); 7737 7710 __netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level, 7738 - NULL); 7711 + priv); 7739 7712 7740 7713 return 0; 7741 7714 ··· 7760 7733 struct net_device *upper_dev, 7761 7734 struct netlink_ext_ack *extack) 7762 7735 { 7736 + struct netdev_nested_priv priv = { 7737 + .flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO, 7738 + .data = NULL, 7739 + }; 7740 + 7763 7741 return __netdev_upper_dev_link(dev, upper_dev, false, 7764 - NULL, NULL, extack); 7742 + NULL, NULL, &priv, extack); 7765 7743 } 7766 7744 EXPORT_SYMBOL(netdev_upper_dev_link); 7767 7745 ··· 7789 7757 void *upper_priv, void *upper_info, 7790 7758 struct netlink_ext_ack *extack) 7791 7759 { 7760 + struct netdev_nested_priv priv = { 7761 + .flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO, 7762 + .data = NULL, 7763 + }; 7764 + 7792 7765 return __netdev_upper_dev_link(dev, upper_dev, true, 7793 - upper_priv, upper_info, extack); 7766 + upper_priv, upper_info, &priv, extack); 7794 7767 } 7795 7768 EXPORT_SYMBOL(netdev_master_upper_dev_link); 7796 7769 7797 - /** 7798 - * netdev_upper_dev_unlink - Removes a link to upper device 7799 - * @dev: device 7800 - * @upper_dev: new upper device 7801 - * 7802 - * Removes a link to device which is upper to this one. The caller must hold 7803 - * the RTNL lock. 7804 - */ 7805 - void netdev_upper_dev_unlink(struct net_device *dev, 7806 - struct net_device *upper_dev) 7770 + static void __netdev_upper_dev_unlink(struct net_device *dev, 7771 + struct net_device *upper_dev, 7772 + struct netdev_nested_priv *priv) 7807 7773 { 7808 7774 struct netdev_notifier_changeupper_info changeupper_info = { 7809 7775 .info = { ··· 7826 7796 __netdev_update_upper_level(dev, NULL); 7827 7797 __netdev_walk_all_lower_dev(dev, __netdev_update_upper_level, NULL); 7828 7798 7829 - __netdev_update_lower_level(upper_dev, NULL); 7799 + __netdev_update_lower_level(upper_dev, priv); 7830 7800 __netdev_walk_all_upper_dev(upper_dev, __netdev_update_lower_level, 7831 - NULL); 7801 + priv); 7802 + } 7803 + 7804 + /** 7805 + * netdev_upper_dev_unlink - Removes a link to upper device 7806 + * @dev: device 7807 + * @upper_dev: new upper device 7808 + * 7809 + * Removes a link to device which is upper to this one. The caller must hold 7810 + * the RTNL lock. 7811 + */ 7812 + void netdev_upper_dev_unlink(struct net_device *dev, 7813 + struct net_device *upper_dev) 7814 + { 7815 + struct netdev_nested_priv priv = { 7816 + .flags = NESTED_SYNC_TODO, 7817 + .data = NULL, 7818 + }; 7819 + 7820 + __netdev_upper_dev_unlink(dev, upper_dev, &priv); 7832 7821 } 7833 7822 EXPORT_SYMBOL(netdev_upper_dev_unlink); 7834 7823 ··· 7883 7834 struct net_device *dev, 7884 7835 struct netlink_ext_ack *extack) 7885 7836 { 7837 + struct netdev_nested_priv priv = { 7838 + .flags = 0, 7839 + .data = NULL, 7840 + }; 7886 7841 int err; 7887 7842 7888 7843 if (!new_dev) ··· 7894 7841 7895 7842 if (old_dev && new_dev != old_dev) 7896 7843 netdev_adjacent_dev_disable(dev, old_dev); 7897 - 7898 - err = netdev_upper_dev_link(new_dev, dev, extack); 7844 + err = __netdev_upper_dev_link(new_dev, dev, false, NULL, NULL, &priv, 7845 + extack); 7899 7846 if (err) { 7900 7847 if (old_dev && new_dev != old_dev) 7901 7848 netdev_adjacent_dev_enable(dev, old_dev); ··· 7910 7857 struct net_device *new_dev, 7911 7858 struct net_device *dev) 7912 7859 { 7860 + struct netdev_nested_priv priv = { 7861 + .flags = NESTED_SYNC_IMM | NESTED_SYNC_TODO, 7862 + .data = NULL, 7863 + }; 7864 + 7913 7865 if (!new_dev || !old_dev) 7914 7866 return; 7915 7867 ··· 7922 7864 return; 7923 7865 7924 7866 netdev_adjacent_dev_enable(dev, old_dev); 7925 - netdev_upper_dev_unlink(old_dev, dev); 7867 + __netdev_upper_dev_unlink(old_dev, dev, &priv); 7926 7868 } 7927 7869 EXPORT_SYMBOL(netdev_adjacent_change_commit); 7928 7870 ··· 7930 7872 struct net_device *new_dev, 7931 7873 struct net_device *dev) 7932 7874 { 7875 + struct netdev_nested_priv priv = { 7876 + .flags = 0, 7877 + .data = NULL, 7878 + }; 7879 + 7933 7880 if (!new_dev) 7934 7881 return; 7935 7882 7936 7883 if (old_dev && new_dev != old_dev) 7937 7884 netdev_adjacent_dev_enable(dev, old_dev); 7938 7885 7939 - netdev_upper_dev_unlink(new_dev, dev); 7886 + __netdev_upper_dev_unlink(new_dev, dev, &priv); 7940 7887 } 7941 7888 EXPORT_SYMBOL(netdev_adjacent_change_abort); 7942 7889 ··· 10125 10062 void netdev_run_todo(void) 10126 10063 { 10127 10064 struct list_head list; 10065 + #ifdef CONFIG_LOCKDEP 10066 + struct list_head unlink_list; 10067 + 10068 + list_replace_init(&net_unlink_list, &unlink_list); 10069 + 10070 + while (!list_empty(&unlink_list)) { 10071 + struct net_device *dev = list_first_entry(&unlink_list, 10072 + struct net_device, 10073 + unlink_list); 10074 + list_del(&dev->unlink_list); 10075 + dev->nested_level = dev->lower_level - 1; 10076 + } 10077 + #endif 10128 10078 10129 10079 /* Snapshot list, allow later requests */ 10130 10080 list_replace_init(&net_todo_list, &list); ··· 10350 10274 dev->gso_max_segs = GSO_MAX_SEGS; 10351 10275 dev->upper_level = 1; 10352 10276 dev->lower_level = 1; 10277 + #ifdef CONFIG_LOCKDEP 10278 + dev->nested_level = 0; 10279 + INIT_LIST_HEAD(&dev->unlink_list); 10280 + #endif 10353 10281 10354 10282 INIT_LIST_HEAD(&dev->napi_list); 10355 10283 INIT_LIST_HEAD(&dev->unreg_list);

+6 -6

net/core/dev_addr_lists.c

··· 637 637 if (to->addr_len != from->addr_len) 638 638 return -EINVAL; 639 639 640 - netif_addr_lock_nested(to); 640 + netif_addr_lock(to); 641 641 err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len); 642 642 if (!err) 643 643 __dev_set_rx_mode(to); ··· 667 667 if (to->addr_len != from->addr_len) 668 668 return -EINVAL; 669 669 670 - netif_addr_lock_nested(to); 670 + netif_addr_lock(to); 671 671 err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len); 672 672 if (!err) 673 673 __dev_set_rx_mode(to); ··· 700 700 * larger. 701 701 */ 702 702 netif_addr_lock_bh(from); 703 - netif_addr_lock_nested(to); 703 + netif_addr_lock(to); 704 704 __hw_addr_unsync(&to->uc, &from->uc, to->addr_len); 705 705 __dev_set_rx_mode(to); 706 706 netif_addr_unlock(to); ··· 867 867 if (to->addr_len != from->addr_len) 868 868 return -EINVAL; 869 869 870 - netif_addr_lock_nested(to); 870 + netif_addr_lock(to); 871 871 err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len); 872 872 if (!err) 873 873 __dev_set_rx_mode(to); ··· 897 897 if (to->addr_len != from->addr_len) 898 898 return -EINVAL; 899 899 900 - netif_addr_lock_nested(to); 900 + netif_addr_lock(to); 901 901 err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len); 902 902 if (!err) 903 903 __dev_set_rx_mode(to); ··· 922 922 923 923 /* See the above comments inside dev_uc_unsync(). */ 924 924 netif_addr_lock_bh(from); 925 - netif_addr_lock_nested(to); 925 + netif_addr_lock(to); 926 926 __hw_addr_unsync(&to->mc, &from->mc, to->addr_len); 927 927 __dev_set_rx_mode(to); 928 928 netif_addr_unlock(to);

+2 -2

net/core/skbuff.c

··· 5622 5622 lse->label_stack_entry = mpls_lse; 5623 5623 skb_postpush_rcsum(skb, lse, MPLS_HLEN); 5624 5624 5625 - if (ethernet) 5625 + if (ethernet && mac_len >= ETH_HLEN) 5626 5626 skb_mod_eth_type(skb, eth_hdr(skb), mpls_proto); 5627 5627 skb->protocol = mpls_proto; 5628 5628 ··· 5662 5662 skb_reset_mac_header(skb); 5663 5663 skb_set_network_header(skb, mac_len); 5664 5664 5665 - if (ethernet) { 5665 + if (ethernet && mac_len >= ETH_HLEN) { 5666 5666 struct ethhdr *hdr; 5667 5667 5668 5668 /* use mpls_hdr() to get ethertype to account for VLANs. */

+1 -1

net/ethtool/netlink.c

··· 866 866 [ETHNL_MCGRP_MONITOR] = { .name = ETHTOOL_MCGRP_MONITOR_NAME }, 867 867 }; 868 868 869 - static struct genl_family ethtool_genl_family = { 869 + static struct genl_family ethtool_genl_family __ro_after_init = { 870 870 .name = ETHTOOL_GENL_NAME, 871 871 .version = ETHTOOL_GENL_VERSION, 872 872 .netnsok = true,

+2

net/ipv4/ip_vti.c

··· 490 490 .priority = 0, 491 491 }; 492 492 493 + #if IS_ENABLED(CONFIG_IPV6) 493 494 static struct xfrm_tunnel vti_ipip6_handler __read_mostly = { 494 495 .handler = vti_rcv_tunnel, 495 496 .cb_handler = vti_rcv_cb, 496 497 .err_handler = vti4_err, 497 498 .priority = 0, 498 499 }; 500 + #endif 499 501 #endif 500 502 501 503 static int __net_init vti_init_net(struct net *net)

+1

net/ipv4/proc.c

··· 293 293 SNMP_MIB_ITEM("TcpTimeoutRehash", LINUX_MIB_TCPTIMEOUTREHASH), 294 294 SNMP_MIB_ITEM("TcpDuplicateDataRehash", LINUX_MIB_TCPDUPLICATEDATAREHASH), 295 295 SNMP_MIB_ITEM("TCPDSACKRecvSegs", LINUX_MIB_TCPDSACKRECVSEGS), 296 + SNMP_MIB_ITEM("TCPDSACKIgnoredDubious", LINUX_MIB_TCPDSACKIGNOREDDUBIOUS), 296 297 SNMP_MIB_SENTINEL 297 298 }; 298 299

+1 -1

net/ipv4/syncookies.c

··· 214 214 sock_rps_save_rxhash(child, skb); 215 215 216 216 if (rsk_drop_req(req)) { 217 - refcount_set(&req->rsk_refcnt, 2); 217 + reqsk_put(req); 218 218 return child; 219 219 } 220 220

+2 -1

net/ipv4/tcp.c

··· 970 970 long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT); 971 971 972 972 if (IS_ENABLED(CONFIG_DEBUG_VM) && 973 - WARN_ONCE(PageSlab(page), "page must not be a Slab one")) 973 + WARN_ONCE(!sendpage_ok(page), 974 + "page must not be a Slab one and have page_count > 0")) 974 975 return -EINVAL; 975 976 976 977 /* Wait for a connection to finish. One exception is TCP Fast Open

+25 -7

net/ipv4/tcp_input.c

··· 885 885 struct rate_sample *rate; 886 886 }; 887 887 888 - /* Take a notice that peer is sending D-SACKs */ 888 + /* Take a notice that peer is sending D-SACKs. Skip update of data delivery 889 + * and spurious retransmission information if this DSACK is unlikely caused by 890 + * sender's action: 891 + * - DSACKed sequence range is larger than maximum receiver's window. 892 + * - Total no. of DSACKed segments exceed the total no. of retransmitted segs. 893 + */ 889 894 static u32 tcp_dsack_seen(struct tcp_sock *tp, u32 start_seq, 890 895 u32 end_seq, struct tcp_sacktag_state *state) 891 896 { 892 897 u32 seq_len, dup_segs = 1; 893 898 894 - if (before(start_seq, end_seq)) { 895 - seq_len = end_seq - start_seq; 896 - if (seq_len > tp->mss_cache) 897 - dup_segs = DIV_ROUND_UP(seq_len, tp->mss_cache); 898 - } 899 + if (!before(start_seq, end_seq)) 900 + return 0; 901 + 902 + seq_len = end_seq - start_seq; 903 + /* Dubious DSACK: DSACKed range greater than maximum advertised rwnd */ 904 + if (seq_len > tp->max_window) 905 + return 0; 906 + if (seq_len > tp->mss_cache) 907 + dup_segs = DIV_ROUND_UP(seq_len, tp->mss_cache); 908 + 909 + tp->dsack_dups += dup_segs; 910 + /* Skip the DSACK if dup segs weren't retransmitted by sender */ 911 + if (tp->dsack_dups > tp->total_retrans) 912 + return 0; 899 913 900 914 tp->rx_opt.sack_ok |= TCP_DSACK_SEEN; 901 915 tp->rack.dsack_seen = 1; 902 - tp->dsack_dups += dup_segs; 903 916 904 917 state->flag |= FLAG_DSACKING_ACK; 905 918 /* A spurious retransmission is delivered */ ··· 1166 1153 } 1167 1154 1168 1155 dup_segs = tcp_dsack_seen(tp, start_seq_0, end_seq_0, state); 1156 + if (!dup_segs) { /* Skip dubious DSACK */ 1157 + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKIGNOREDDUBIOUS); 1158 + return false; 1159 + } 1160 + 1169 1161 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECVSEGS, dup_segs); 1170 1162 1171 1163 /* D-SACK for already forgotten data... Do dumb counting. */

+6 -5

net/mptcp/options.c

··· 518 518 519 519 if (subflow->use_64bit_ack) { 520 520 ack_size = TCPOLEN_MPTCP_DSS_ACK64; 521 - opts->ext_copy.data_ack = msk->ack_seq; 521 + opts->ext_copy.data_ack = READ_ONCE(msk->ack_seq); 522 522 opts->ext_copy.ack64 = 1; 523 523 } else { 524 524 ack_size = TCPOLEN_MPTCP_DSS_ACK32; 525 - opts->ext_copy.data_ack32 = (uint32_t)(msk->ack_seq); 525 + opts->ext_copy.data_ack32 = (uint32_t)READ_ONCE(msk->ack_seq); 526 526 opts->ext_copy.ack64 = 0; 527 527 } 528 528 opts->ext_copy.use_ack = 1; ··· 782 782 } 783 783 } 784 784 785 - bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq) 785 + bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq, bool use_64bit) 786 786 { 787 787 /* Skip if DATA_FIN was already received. 788 788 * If updating simultaneously with the recvmsg loop, values ··· 792 792 if (READ_ONCE(msk->rcv_data_fin) || !READ_ONCE(msk->first)) 793 793 return false; 794 794 795 - WRITE_ONCE(msk->rcv_data_fin_seq, data_fin_seq); 795 + WRITE_ONCE(msk->rcv_data_fin_seq, 796 + expand_ack(READ_ONCE(msk->ack_seq), data_fin_seq, use_64bit)); 796 797 WRITE_ONCE(msk->rcv_data_fin, 1); 797 798 798 799 return true; ··· 876 875 */ 877 876 if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) { 878 877 if (mp_opt.data_fin && mp_opt.data_len == 1 && 879 - mptcp_update_rcv_data_fin(msk, mp_opt.data_seq) && 878 + mptcp_update_rcv_data_fin(msk, mp_opt.data_seq, mp_opt.dsn64) && 880 879 schedule_work(&msk->work)) 881 880 sock_hold(subflow->conn); 882 881

+4 -4

net/mptcp/protocol.c

··· 123 123 124 124 skb_ext_reset(skb); 125 125 skb_orphan(skb); 126 - msk->ack_seq += copy_len; 126 + WRITE_ONCE(msk->ack_seq, msk->ack_seq + copy_len); 127 127 128 128 tail = skb_peek_tail(&sk->sk_receive_queue); 129 129 if (offset == 0 && tail) { ··· 261 261 if (mptcp_pending_data_fin(sk, &rcv_data_fin_seq)) { 262 262 struct mptcp_subflow_context *subflow; 263 263 264 - msk->ack_seq++; 264 + WRITE_ONCE(msk->ack_seq, msk->ack_seq + 1); 265 265 WRITE_ONCE(msk->rcv_data_fin, 0); 266 266 267 267 sk->sk_shutdown |= RCV_SHUTDOWN; ··· 1720 1720 msk->remote_key = mp_opt->sndr_key; 1721 1721 mptcp_crypto_key_sha(msk->remote_key, NULL, &ack_seq); 1722 1722 ack_seq++; 1723 - msk->ack_seq = ack_seq; 1723 + WRITE_ONCE(msk->ack_seq, ack_seq); 1724 1724 } 1725 1725 1726 1726 sock_reset_flag(nsk, SOCK_RCU_FREE); ··· 2072 2072 parent_sock = READ_ONCE(parent->sk_socket); 2073 2073 if (parent_sock && !sk->sk_socket) 2074 2074 mptcp_sock_graft(sk, parent_sock); 2075 - subflow->map_seq = msk->ack_seq; 2075 + subflow->map_seq = READ_ONCE(msk->ack_seq); 2076 2076 return true; 2077 2077 } 2078 2078

+1 -1

net/mptcp/protocol.h

··· 387 387 bool mptcp_finish_join(struct sock *sk); 388 388 void mptcp_data_acked(struct sock *sk); 389 389 void mptcp_subflow_eof(struct sock *sk); 390 - bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq); 390 + bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq, bool use_64bit); 391 391 392 392 void __init mptcp_token_init(void); 393 393 static inline void mptcp_token_init_request(struct request_sock *req)

+16 -3

net/mptcp/subflow.c

··· 731 731 732 732 if (mpext->data_fin == 1) { 733 733 if (data_len == 1) { 734 - mptcp_update_rcv_data_fin(msk, mpext->data_seq); 734 + bool updated = mptcp_update_rcv_data_fin(msk, mpext->data_seq, 735 + mpext->dsn64); 735 736 pr_debug("DATA_FIN with no payload seq=%llu", mpext->data_seq); 736 737 if (subflow->map_valid) { 737 738 /* A DATA_FIN might arrive in a DSS ··· 743 742 skb_ext_del(skb, SKB_EXT_MPTCP); 744 743 return MAPPING_OK; 745 744 } else { 745 + if (updated && schedule_work(&msk->work)) 746 + sock_hold((struct sock *)msk); 747 + 746 748 return MAPPING_DATA_FIN; 747 749 } 748 750 } else { 749 - mptcp_update_rcv_data_fin(msk, mpext->data_seq + data_len); 750 - pr_debug("DATA_FIN with mapping seq=%llu", mpext->data_seq + data_len); 751 + u64 data_fin_seq = mpext->data_seq + data_len; 752 + 753 + /* If mpext->data_seq is a 32-bit value, data_fin_seq 754 + * must also be limited to 32 bits. 755 + */ 756 + if (!mpext->dsn64) 757 + data_fin_seq &= GENMASK_ULL(31, 0); 758 + 759 + mptcp_update_rcv_data_fin(msk, data_fin_seq, mpext->dsn64); 760 + pr_debug("DATA_FIN with mapping seq=%llu dsn64=%d", 761 + data_fin_seq, mpext->dsn64); 751 762 } 752 763 753 764 /* Adjust for DATA_FIN using 1 byte of sequence space */

+8 -1

net/netlink/genetlink.c

··· 1079 1079 if (err) 1080 1080 return err; 1081 1081 1082 - while (netlink_policy_dump_loop(&cb->args[1])) { 1082 + while (netlink_policy_dump_loop(cb->args[1])) { 1083 1083 void *hdr; 1084 1084 struct nlattr *nest; 1085 1085 ··· 1113 1113 return skb->len; 1114 1114 } 1115 1115 1116 + static int ctrl_dumppolicy_done(struct netlink_callback *cb) 1117 + { 1118 + netlink_policy_dump_free(cb->args[1]); 1119 + return 0; 1120 + } 1121 + 1116 1122 static const struct genl_ops genl_ctrl_ops[] = { 1117 1123 { 1118 1124 .cmd = CTRL_CMD_GETFAMILY, ··· 1129 1123 { 1130 1124 .cmd = CTRL_CMD_GETPOLICY, 1131 1125 .dumpit = ctrl_dumppolicy, 1126 + .done = ctrl_dumppolicy_done, 1132 1127 }, 1133 1128 }; 1134 1129

+10 -14

net/netlink/policy.c

··· 84 84 unsigned int policy_idx; 85 85 int err; 86 86 87 - /* also returns 0 if "*_state" is our ERR_PTR() end marker */ 88 87 if (*_state) 89 88 return 0; 90 89 ··· 139 140 !state->policies[state->policy_idx].policy; 140 141 } 141 142 142 - bool netlink_policy_dump_loop(unsigned long *_state) 143 + bool netlink_policy_dump_loop(unsigned long _state) 143 144 { 144 - struct nl_policy_dump *state = (void *)*_state; 145 + struct nl_policy_dump *state = (void *)_state; 145 146 146 - if (IS_ERR(state)) 147 - return false; 148 - 149 - if (netlink_policy_dump_finished(state)) { 150 - kfree(state); 151 - /* store end marker instead of freed state */ 152 - *_state = (unsigned long)ERR_PTR(-ENOENT); 153 - return false; 154 - } 155 - 156 - return true; 147 + return !netlink_policy_dump_finished(state); 157 148 } 158 149 159 150 int netlink_policy_dump_write(struct sk_buff *skb, unsigned long _state) ··· 297 308 nla_put_failure: 298 309 nla_nest_cancel(skb, policy); 299 310 return -ENOBUFS; 311 + } 312 + 313 + void netlink_policy_dump_free(unsigned long _state) 314 + { 315 + struct nl_policy_dump *state = (void *)_state; 316 + 317 + kfree(state); 300 318 }

+25 -9

net/qrtr/ns.c

··· 193 193 struct qrtr_server *srv; 194 194 struct qrtr_node *node; 195 195 void __rcu **slot; 196 - int ret; 196 + int ret = 0; 197 197 198 198 node = node_get(qrtr_ns.local_node); 199 199 if (!node) 200 200 return 0; 201 201 202 + rcu_read_lock(); 202 203 /* Announce the list of servers registered in this node */ 203 204 radix_tree_for_each_slot(slot, &node->servers, &iter, 0) { 204 205 srv = radix_tree_deref_slot(slot); ··· 207 206 ret = service_announce_new(sq, srv); 208 207 if (ret < 0) { 209 208 pr_err("failed to announce new service\n"); 210 - return ret; 209 + goto err_out; 211 210 } 212 211 } 213 212 214 - return 0; 213 + err_out: 214 + rcu_read_unlock(); 215 + 216 + return ret; 215 217 } 216 218 217 219 static struct qrtr_server *server_add(unsigned int service, ··· 339 335 struct qrtr_node *node; 340 336 void __rcu **slot; 341 337 struct kvec iv; 342 - int ret; 338 + int ret = 0; 343 339 344 340 iv.iov_base = &pkt; 345 341 iv.iov_len = sizeof(pkt); ··· 348 344 if (!node) 349 345 return 0; 350 346 347 + rcu_read_lock(); 351 348 /* Advertise removal of this client to all servers of remote node */ 352 349 radix_tree_for_each_slot(slot, &node->servers, &iter, 0) { 353 350 srv = radix_tree_deref_slot(slot); 354 351 server_del(node, srv->port); 355 352 } 353 + rcu_read_unlock(); 356 354 357 355 /* Advertise the removal of this client to all local servers */ 358 356 local_node = node_get(qrtr_ns.local_node); ··· 365 359 pkt.cmd = cpu_to_le32(QRTR_TYPE_BYE); 366 360 pkt.client.node = cpu_to_le32(from->sq_node); 367 361 362 + rcu_read_lock(); 368 363 radix_tree_for_each_slot(slot, &local_node->servers, &iter, 0) { 369 364 srv = radix_tree_deref_slot(slot); 370 365 ··· 379 372 ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt)); 380 373 if (ret < 0) { 381 374 pr_err("failed to send bye cmd\n"); 382 - return ret; 375 + goto err_out; 383 376 } 384 377 } 385 378 386 - return 0; 379 + err_out: 380 + rcu_read_unlock(); 381 + 382 + return ret; 387 383 } 388 384 389 385 static int ctrl_cmd_del_client(struct sockaddr_qrtr *from, ··· 404 394 struct list_head *li; 405 395 void __rcu **slot; 406 396 struct kvec iv; 407 - int ret; 397 + int ret = 0; 408 398 409 399 iv.iov_base = &pkt; 410 400 iv.iov_len = sizeof(pkt); ··· 444 434 pkt.client.node = cpu_to_le32(node_id); 445 435 pkt.client.port = cpu_to_le32(port); 446 436 437 + rcu_read_lock(); 447 438 radix_tree_for_each_slot(slot, &local_node->servers, &iter, 0) { 448 439 srv = radix_tree_deref_slot(slot); 449 440 ··· 458 447 ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt)); 459 448 if (ret < 0) { 460 449 pr_err("failed to send del client cmd\n"); 461 - return ret; 450 + goto err_out; 462 451 } 463 452 } 464 453 465 - return 0; 454 + err_out: 455 + rcu_read_unlock(); 456 + 457 + return ret; 466 458 } 467 459 468 460 static int ctrl_cmd_new_server(struct sockaddr_qrtr *from, ··· 568 554 filter.service = service; 569 555 filter.instance = instance; 570 556 557 + rcu_read_lock(); 571 558 radix_tree_for_each_slot(node_slot, &nodes, &node_iter, 0) { 572 559 node = radix_tree_deref_slot(node_slot); 573 560 ··· 583 568 lookup_notify(from, srv, true); 584 569 } 585 570 } 571 + rcu_read_unlock(); 586 572 587 573 /* Empty notification, to indicate end of listing */ 588 574 lookup_notify(from, NULL, true);

+29 -25

net/sched/act_api.c

··· 235 235 index++; 236 236 if (index < s_i) 237 237 continue; 238 + if (IS_ERR(p)) 239 + continue; 238 240 239 241 if (jiffy_since && 240 242 time_after(jiffy_since, ··· 309 307 310 308 mutex_lock(&idrinfo->lock); 311 309 idr_for_each_entry_ul(idr, p, tmp, id) { 310 + if (IS_ERR(p)) 311 + continue; 312 312 ret = tcf_idr_release_unsafe(p); 313 313 if (ret == ACT_P_DELETED) { 314 314 module_put(ops->owner); ··· 470 466 !(flags & TCA_ACT_FLAGS_NO_PERCPU_STATS), flags); 471 467 } 472 468 EXPORT_SYMBOL(tcf_idr_create_from_flags); 473 - 474 - void tcf_idr_insert(struct tc_action_net *tn, struct tc_action *a) 475 - { 476 - struct tcf_idrinfo *idrinfo = tn->idrinfo; 477 - 478 - mutex_lock(&idrinfo->lock); 479 - /* Replace ERR_PTR(-EBUSY) allocated by tcf_idr_check_alloc */ 480 - WARN_ON(!IS_ERR(idr_replace(&idrinfo->action_idr, a, a->tcfa_index))); 481 - mutex_unlock(&idrinfo->lock); 482 - } 483 - EXPORT_SYMBOL(tcf_idr_insert); 484 469 485 470 /* Cleanup idr index that was allocated but not initialized. */ 486 471 ··· 724 731 return ret; 725 732 } 726 733 727 - static int tcf_action_destroy_1(struct tc_action *a, int bind) 728 - { 729 - struct tc_action *actions[] = { a, NULL }; 730 - 731 - return tcf_action_destroy(actions, bind); 732 - } 733 - 734 734 static int tcf_action_put(struct tc_action *p) 735 735 { 736 736 return __tcf_action_put(p, false); ··· 888 902 [TCA_ACT_HW_STATS] = NLA_POLICY_BITFIELD32(TCA_ACT_HW_STATS_ANY), 889 903 }; 890 904 905 + static void tcf_idr_insert_many(struct tc_action *actions[]) 906 + { 907 + int i; 908 + 909 + for (i = 0; i < TCA_ACT_MAX_PRIO; i++) { 910 + struct tc_action *a = actions[i]; 911 + struct tcf_idrinfo *idrinfo; 912 + 913 + if (!a) 914 + continue; 915 + idrinfo = a->idrinfo; 916 + mutex_lock(&idrinfo->lock); 917 + /* Replace ERR_PTR(-EBUSY) allocated by tcf_idr_check_alloc if 918 + * it is just created, otherwise this is just a nop. 919 + */ 920 + idr_replace(&idrinfo->action_idr, a, a->tcfa_index); 921 + mutex_unlock(&idrinfo->lock); 922 + } 923 + } 924 + 891 925 struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp, 892 926 struct nlattr *nla, struct nlattr *est, 893 927 char *name, int ovr, int bind, ··· 1008 1002 if (err != ACT_P_CREATED) 1009 1003 module_put(a_o->owner); 1010 1004 1011 - if (TC_ACT_EXT_CMP(a->tcfa_action, TC_ACT_GOTO_CHAIN) && 1012 - !rcu_access_pointer(a->goto_chain)) { 1013 - tcf_action_destroy_1(a, bind); 1014 - NL_SET_ERR_MSG(extack, "can't use goto chain with NULL chain"); 1015 - return ERR_PTR(-EINVAL); 1016 - } 1017 - 1018 1005 return a; 1019 1006 1020 1007 err_mod: ··· 1049 1050 /* Start from index 0 */ 1050 1051 actions[i - 1] = act; 1051 1052 } 1053 + 1054 + /* We have to commit them all together, because if any error happened in 1055 + * between, we could not handle the failure gracefully. 1056 + */ 1057 + tcf_idr_insert_many(actions); 1052 1058 1053 1059 *attr_size = tcf_action_full_attrs_size(sz); 1054 1060 return i - 1;

+1 -3

net/sched/act_bpf.c

··· 365 365 if (goto_ch) 366 366 tcf_chain_put_by_act(goto_ch); 367 367 368 - if (res == ACT_P_CREATED) { 369 - tcf_idr_insert(tn, *act); 370 - } else { 368 + if (res != ACT_P_CREATED) { 371 369 /* make sure the program being replaced is no longer executing */ 372 370 synchronize_rcu(); 373 371 tcf_bpf_cfg_cleanup(&old);

-1

net/sched/act_connmark.c

··· 139 139 ci->net = net; 140 140 ci->zone = parm->zone; 141 141 142 - tcf_idr_insert(tn, *a); 143 142 ret = ACT_P_CREATED; 144 143 } else if (ret > 0) { 145 144 ci = to_connmark(*a);

-3

net/sched/act_csum.c

··· 110 110 if (params_new) 111 111 kfree_rcu(params_new, rcu); 112 112 113 - if (ret == ACT_P_CREATED) 114 - tcf_idr_insert(tn, *a); 115 - 116 113 return ret; 117 114 put_chain: 118 115 if (goto_ch)

-2

net/sched/act_ct.c

··· 1297 1297 tcf_chain_put_by_act(goto_ch); 1298 1298 if (params) 1299 1299 call_rcu(&params->rcu, tcf_ct_params_free); 1300 - if (res == ACT_P_CREATED) 1301 - tcf_idr_insert(tn, *a); 1302 1300 1303 1301 return res; 1304 1302

-3

net/sched/act_ctinfo.c

··· 269 269 if (cp_new) 270 270 kfree_rcu(cp_new, rcu); 271 271 272 - if (ret == ACT_P_CREATED) 273 - tcf_idr_insert(tn, *a); 274 - 275 272 return ret; 276 273 277 274 put_chain:

-2

net/sched/act_gact.c

··· 140 140 if (goto_ch) 141 141 tcf_chain_put_by_act(goto_ch); 142 142 143 - if (ret == ACT_P_CREATED) 144 - tcf_idr_insert(tn, *a); 145 143 return ret; 146 144 release_idr: 147 145 tcf_idr_release(*a, bind);

-3

net/sched/act_gate.c

··· 437 437 if (goto_ch) 438 438 tcf_chain_put_by_act(goto_ch); 439 439 440 - if (ret == ACT_P_CREATED) 441 - tcf_idr_insert(tn, *a); 442 - 443 440 return ret; 444 441 445 442 chain_put:

-3

net/sched/act_ife.c

··· 627 627 if (p) 628 628 kfree_rcu(p, rcu); 629 629 630 - if (ret == ACT_P_CREATED) 631 - tcf_idr_insert(tn, *a); 632 - 633 630 return ret; 634 631 metadata_parse_err: 635 632 if (goto_ch)

-2

net/sched/act_ipt.c

··· 189 189 ipt->tcfi_t = t; 190 190 ipt->tcfi_hook = hook; 191 191 spin_unlock_bh(&ipt->tcf_lock); 192 - if (ret == ACT_P_CREATED) 193 - tcf_idr_insert(tn, *a); 194 192 return ret; 195 193 196 194 err3:

-2

net/sched/act_mirred.c

··· 194 194 spin_lock(&mirred_list_lock); 195 195 list_add(&m->tcfm_list, &mirred_list); 196 196 spin_unlock(&mirred_list_lock); 197 - 198 - tcf_idr_insert(tn, *a); 199 197 } 200 198 201 199 return ret;

-2

net/sched/act_mpls.c

··· 273 273 if (p) 274 274 kfree_rcu(p, rcu); 275 275 276 - if (ret == ACT_P_CREATED) 277 - tcf_idr_insert(tn, *a); 278 276 return ret; 279 277 put_chain: 280 278 if (goto_ch)

-3

net/sched/act_nat.c

··· 93 93 if (goto_ch) 94 94 tcf_chain_put_by_act(goto_ch); 95 95 96 - if (ret == ACT_P_CREATED) 97 - tcf_idr_insert(tn, *a); 98 - 99 96 return ret; 100 97 release_idr: 101 98 tcf_idr_release(*a, bind);

-2

net/sched/act_pedit.c

··· 238 238 spin_unlock_bh(&p->tcf_lock); 239 239 if (goto_ch) 240 240 tcf_chain_put_by_act(goto_ch); 241 - if (ret == ACT_P_CREATED) 242 - tcf_idr_insert(tn, *a); 243 241 return ret; 244 242 245 243 put_chain:

-2

net/sched/act_police.c

··· 201 201 if (new) 202 202 kfree_rcu(new, rcu); 203 203 204 - if (ret == ACT_P_CREATED) 205 - tcf_idr_insert(tn, *a); 206 204 return ret; 207 205 208 206 failure:

-2

net/sched/act_sample.c

··· 116 116 if (goto_ch) 117 117 tcf_chain_put_by_act(goto_ch); 118 118 119 - if (ret == ACT_P_CREATED) 120 - tcf_idr_insert(tn, *a); 121 119 return ret; 122 120 put_chain: 123 121 if (goto_ch)

-2

net/sched/act_simple.c

··· 157 157 goto release_idr; 158 158 } 159 159 160 - if (ret == ACT_P_CREATED) 161 - tcf_idr_insert(tn, *a); 162 160 return ret; 163 161 put_chain: 164 162 if (goto_ch)

-2

net/sched/act_skbedit.c

··· 225 225 if (goto_ch) 226 226 tcf_chain_put_by_act(goto_ch); 227 227 228 - if (ret == ACT_P_CREATED) 229 - tcf_idr_insert(tn, *a); 230 228 return ret; 231 229 put_chain: 232 230 if (goto_ch)

-2

net/sched/act_skbmod.c

··· 190 190 if (goto_ch) 191 191 tcf_chain_put_by_act(goto_ch); 192 192 193 - if (ret == ACT_P_CREATED) 194 - tcf_idr_insert(tn, *a); 195 193 return ret; 196 194 put_chain: 197 195 if (goto_ch)

-3

net/sched/act_tunnel_key.c

··· 537 537 if (goto_ch) 538 538 tcf_chain_put_by_act(goto_ch); 539 539 540 - if (ret == ACT_P_CREATED) 541 - tcf_idr_insert(tn, *a); 542 - 543 540 return ret; 544 541 545 542 put_chain:

-2

net/sched/act_vlan.c

··· 229 229 if (p) 230 230 kfree_rcu(p, rcu); 231 231 232 - if (ret == ACT_P_CREATED) 233 - tcf_idr_insert(tn, *a); 234 232 return ret; 235 233 put_chain: 236 234 if (goto_ch)

+4 -2

net/socket.c

··· 3638 3638 int kernel_sendpage(struct socket *sock, struct page *page, int offset, 3639 3639 size_t size, int flags) 3640 3640 { 3641 - if (sock->ops->sendpage) 3641 + if (sock->ops->sendpage) { 3642 + /* Warn in case the improper page to zero-copy send */ 3643 + WARN_ONCE(!sendpage_ok(page), "improper page for zero-copy send"); 3642 3644 return sock->ops->sendpage(sock, page, offset, size, flags); 3643 - 3645 + } 3644 3646 return sock_no_sendpage(sock, page, offset, size, flags); 3645 3647 } 3646 3648 EXPORT_SYMBOL(kernel_sendpage);

+1 -1

net/switchdev/switchdev.c

··· 404 404 * @val: value passed unmodified to notifier function 405 405 * @dev: port device 406 406 * @info: notifier information data 407 - * 407 + * @extack: netlink extended ack 408 408 * Call all network notifier blocks. 409 409 */ 410 410 int call_switchdev_notifiers(unsigned long val, struct net_device *dev,

+7 -2

net/tls/tls_sw.c

··· 2143 2143 struct tls_context *tls_ctx = tls_get_ctx(sk); 2144 2144 struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx); 2145 2145 struct tls_rec *rec, *tmp; 2146 + int pending; 2146 2147 2147 2148 /* Wait for any pending async encryptions to complete */ 2148 - smp_store_mb(ctx->async_notify, true); 2149 - if (atomic_read(&ctx->encrypt_pending)) 2149 + spin_lock_bh(&ctx->encrypt_compl_lock); 2150 + ctx->async_notify = true; 2151 + pending = atomic_read(&ctx->encrypt_pending); 2152 + spin_unlock_bh(&ctx->encrypt_compl_lock); 2153 + 2154 + if (pending) 2150 2155 crypto_wait_req(-EINPROGRESS, &ctx->async_wait); 2151 2156 2152 2157 tls_tx_records(sk, -1);

+16 -1

net/xdp/xsk.c

··· 377 377 skb_shinfo(skb)->destructor_arg = (void *)(long)desc.addr; 378 378 skb->destructor = xsk_destruct_skb; 379 379 380 + /* Hinder dev_direct_xmit from freeing the packet and 381 + * therefore completing it in the destructor 382 + */ 383 + refcount_inc(&skb->users); 380 384 err = dev_direct_xmit(skb, xs->queue_id); 385 + if (err == NETDEV_TX_BUSY) { 386 + /* Tell user-space to retry the send */ 387 + skb->destructor = sock_wfree; 388 + /* Free skb without triggering the perf drop trace */ 389 + consume_skb(skb); 390 + err = -EAGAIN; 391 + goto out; 392 + } 393 + 381 394 xskq_cons_release(xs->tx); 382 395 /* Ignore NET_XMIT_CN as packet might have been sent */ 383 - if (err == NET_XMIT_DROP || err == NETDEV_TX_BUSY) { 396 + if (err == NET_XMIT_DROP) { 384 397 /* SKB completed but not sent */ 398 + kfree_skb(skb); 385 399 err = -EBUSY; 386 400 goto out; 387 401 } 388 402 403 + consume_skb(skb); 389 404 sent_frame = true; 390 405 } 391 406

+5 -1

net/xfrm/espintcp.c

··· 29 29 30 30 static void handle_esp(struct sk_buff *skb, struct sock *sk) 31 31 { 32 + struct tcp_skb_cb *tcp_cb = (struct tcp_skb_cb *)skb->cb; 33 + 32 34 skb_reset_transport_header(skb); 33 - memset(skb->cb, 0, sizeof(skb->cb)); 35 + 36 + /* restore IP CB, we need at least IP6CB->nhoff */ 37 + memmove(skb->cb, &tcp_cb->header, sizeof(tcp_cb->header)); 34 38 35 39 rcu_read_lock(); 36 40 skb->dev = dev_get_by_index_rcu(sock_net(sk), skb->skb_iif);

+1 -1

net/xfrm/xfrm_interface.c

··· 303 303 } 304 304 305 305 mtu = dst_mtu(dst); 306 - if (!skb->ignore_df && skb->len > mtu) { 306 + if (skb->len > mtu) { 307 307 skb_dst_update_pmtu_no_confirm(skb, mtu); 308 308 309 309 if (skb->protocol == htons(ETH_P_IPV6)) {

+37 -5

net/xfrm/xfrm_state.c

··· 1019 1019 */ 1020 1020 if (x->km.state == XFRM_STATE_VALID) { 1021 1021 if ((x->sel.family && 1022 - !xfrm_selector_match(&x->sel, fl, x->sel.family)) || 1022 + (x->sel.family != family || 1023 + !xfrm_selector_match(&x->sel, fl, family))) || 1023 1024 !security_xfrm_state_pol_flow_match(x, pol, fl)) 1024 1025 return; 1025 1026 ··· 1033 1032 *acq_in_progress = 1; 1034 1033 } else if (x->km.state == XFRM_STATE_ERROR || 1035 1034 x->km.state == XFRM_STATE_EXPIRED) { 1036 - if (xfrm_selector_match(&x->sel, fl, x->sel.family) && 1035 + if ((!x->sel.family || 1036 + (x->sel.family == family && 1037 + xfrm_selector_match(&x->sel, fl, family))) && 1037 1038 security_xfrm_state_pol_flow_match(x, pol, fl)) 1038 1039 *error = -ESRCH; 1039 1040 } ··· 1075 1072 tmpl->mode == x->props.mode && 1076 1073 tmpl->id.proto == x->id.proto && 1077 1074 (tmpl->id.spi == x->id.spi || !tmpl->id.spi)) 1078 - xfrm_state_look_at(pol, x, fl, encap_family, 1075 + xfrm_state_look_at(pol, x, fl, family, 1079 1076 &best, &acquire_in_progress, &error); 1080 1077 } 1081 1078 if (best || acquire_in_progress) ··· 1092 1089 tmpl->mode == x->props.mode && 1093 1090 tmpl->id.proto == x->id.proto && 1094 1091 (tmpl->id.spi == x->id.spi || !tmpl->id.spi)) 1095 - xfrm_state_look_at(pol, x, fl, encap_family, 1092 + xfrm_state_look_at(pol, x, fl, family, 1096 1093 &best, &acquire_in_progress, &error); 1097 1094 } 1098 1095 ··· 1444 1441 EXPORT_SYMBOL(xfrm_state_add); 1445 1442 1446 1443 #ifdef CONFIG_XFRM_MIGRATE 1444 + static inline int clone_security(struct xfrm_state *x, struct xfrm_sec_ctx *security) 1445 + { 1446 + struct xfrm_user_sec_ctx *uctx; 1447 + int size = sizeof(*uctx) + security->ctx_len; 1448 + int err; 1449 + 1450 + uctx = kmalloc(size, GFP_KERNEL); 1451 + if (!uctx) 1452 + return -ENOMEM; 1453 + 1454 + uctx->exttype = XFRMA_SEC_CTX; 1455 + uctx->len = size; 1456 + uctx->ctx_doi = security->ctx_doi; 1457 + uctx->ctx_alg = security->ctx_alg; 1458 + uctx->ctx_len = security->ctx_len; 1459 + memcpy(uctx + 1, security->ctx_str, security->ctx_len); 1460 + err = security_xfrm_state_alloc(x, uctx); 1461 + kfree(uctx); 1462 + if (err) 1463 + return err; 1464 + 1465 + return 0; 1466 + } 1467 + 1447 1468 static struct xfrm_state *xfrm_state_clone(struct xfrm_state *orig, 1448 1469 struct xfrm_encap_tmpl *encap) 1449 1470 { ··· 1524 1497 goto error; 1525 1498 } 1526 1499 1500 + if (orig->security) 1501 + if (clone_security(x, orig->security)) 1502 + goto error; 1503 + 1527 1504 if (orig->coaddr) { 1528 1505 x->coaddr = kmemdup(orig->coaddr, sizeof(*x->coaddr), 1529 1506 GFP_KERNEL); ··· 1541 1510 } 1542 1511 1543 1512 memcpy(&x->mark, &orig->mark, sizeof(x->mark)); 1513 + memcpy(&x->props.smark, &orig->props.smark, sizeof(x->props.smark)); 1544 1514 1545 1515 if (xfrm_init_state(x) < 0) 1546 1516 goto error; ··· 1553 1521 x->tfcpad = orig->tfcpad; 1554 1522 x->replay_maxdiff = orig->replay_maxdiff; 1555 1523 x->replay_maxage = orig->replay_maxage; 1556 - x->curlft.add_time = orig->curlft.add_time; 1524 + memcpy(&x->curlft, &orig->curlft, sizeof(x->curlft)); 1557 1525 x->km.state = orig->km.state; 1558 1526 x->km.seq = orig->km.seq; 1559 1527 x->replay = orig->replay;

+1 -1

tools/bpf/bpftool/Makefile

··· 25 25 26 26 LIBBPF = $(LIBBPF_PATH)libbpf.a 27 27 28 - BPFTOOL_VERSION := $(shell make -rR --no-print-directory -sC ../../.. kernelversion) 28 + BPFTOOL_VERSION ?= $(shell make -rR --no-print-directory -sC ../../.. kernelversion) 29 29 30 30 $(LIBBPF): FORCE 31 31 $(if $(LIBBPF_OUTPUT),@mkdir -p $(LIBBPF_OUTPUT))

+6

tools/lib/bpf/btf.c

··· 659 659 err = -EIO; 660 660 goto err_out; 661 661 } 662 + if (magic == __bswap_16(BTF_MAGIC)) { 663 + /* non-native endian raw BTF */ 664 + pr_warn("non-native BTF endianness is not supported\n"); 665 + err = -LIBBPF_ERRNO__ENDIAN; 666 + goto err_out; 667 + } 662 668 if (magic != BTF_MAGIC) { 663 669 /* definitely not a raw BTF */ 664 670 err = -EPROTO;

+1 -1

tools/lib/bpf/libbpf.c

··· 6925 6925 BPF_XDP_DEVMAP), 6926 6926 BPF_EAPROG_SEC("xdp_cpumap/", BPF_PROG_TYPE_XDP, 6927 6927 BPF_XDP_CPUMAP), 6928 - BPF_EAPROG_SEC("xdp", BPF_PROG_TYPE_XDP, 6928 + BPF_APROG_SEC("xdp", BPF_PROG_TYPE_XDP, 6929 6929 BPF_XDP), 6930 6930 BPF_PROG_SEC("perf_event", BPF_PROG_TYPE_PERF_EVENT), 6931 6931 BPF_PROG_SEC("lwt_in", BPF_PROG_TYPE_LWT_IN),

Configure Feed

Configure Feed