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

Configure Feed

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

Merge tag 'net-6.14-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

Pull networking fixes from Jakub Kicinski:
"Including fixes from bluetooth.

We didn't get netfilter or wireless PRs this week, so next week's PR
is probably going to be bigger. A healthy dose of fixes for bugs
introduced in the current release nonetheless.

Current release - regressions:

- Bluetooth: always allow SCO packets for user channel

- af_unix: fix memory leak in unix_dgram_sendmsg()

- rxrpc:
- remove redundant peer->mtu_lock causing lockdep splats
- fix spinlock flavor issues with the peer record hash

- eth: iavf: fix circular lock dependency with netdev_lock

- net: use rtnl_net_dev_lock() in
register_netdevice_notifier_dev_net() RDMA driver register notifier
after the device

Current release - new code bugs:

- ethtool: fix ioctl confusing drivers about desired HDS user config

- eth: ixgbe: fix media cage present detection for E610 device

Previous releases - regressions:

- loopback: avoid sending IP packets without an Ethernet header

- mptcp: reset connection when MPTCP opts are dropped after join

Previous releases - always broken:

- net: better track kernel sockets lifetime

- ipv6: fix dst ref loop on input in seg6 and rpl lw tunnels

- phy: qca807x: use right value from DTS for DAC_DSP_BIAS_CURRENT

- eth: enetc: number of error handling fixes

- dsa: rtl8366rb: reshuffle the code to fix config / build issue with
LED support"

* tag 'net-6.14-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (53 commits)
net: ti: icss-iep: Reject perout generation request
idpf: fix checksums set in idpf_rx_rsc()
selftests: drv-net: Check if combined-count exists
net: ipv6: fix dst ref loop on input in rpl lwt
net: ipv6: fix dst ref loop on input in seg6 lwt
usbnet: gl620a: fix endpoint checking in genelink_bind()
net/mlx5: IRQ, Fix null string in debug print
net/mlx5: Restore missing trace event when enabling vport QoS
net/mlx5: Fix vport QoS cleanup on error
net: mvpp2: cls: Fixed Non IP flow, with vlan tag flow defination.
af_unix: Fix memory leak in unix_dgram_sendmsg()
net: Handle napi_schedule() calls from non-interrupt
net: Clear old fragment checksum value in napi_reuse_skb
gve: unlink old napi when stopping a queue using queue API
net: Use rtnl_net_dev_lock() in register_netdevice_notifier_dev_net().
tcp: Defer ts_recent changes until req is owned
net: enetc: fix the off-by-one issue in enetc_map_tx_tso_buffs()
net: enetc: remove the mm_lock from the ENETC v4 driver
net: enetc: add missing enetc4_link_deinit()
net: enetc: update UDP checksum when updating originTimestamp field
...

Linus Torvalds 1e15510b f09d694c

+792 -461
+4 -1
MAINTAINERS
··· 2878 2878 2879 2879 ARM/NXP S32G/S32R DWMAC ETHERNET DRIVER 2880 2880 M: Jan Petrous <jan.petrous@oss.nxp.com> 2881 - L: NXP S32 Linux Team <s32@nxp.com> 2881 + R: s32@nxp.com 2882 2882 S: Maintained 2883 2883 F: Documentation/devicetree/bindings/net/nxp,s32-dwmac.yaml 2884 2884 F: drivers/net/ethernet/stmicro/stmmac/dwmac-s32.c ··· 21922 21922 21923 21923 SOCKET TIMESTAMPING 21924 21924 M: Willem de Bruijn <willemdebruijn.kernel@gmail.com> 21925 + R: Jason Xing <kernelxing@tencent.com> 21925 21926 S: Maintained 21926 21927 F: Documentation/networking/timestamping.rst 21927 21928 F: include/linux/net_tstamp.h 21928 21929 F: include/uapi/linux/net_tstamp.h 21930 + F: tools/testing/selftests/bpf/*/net_timestamping* 21931 + F: tools/testing/selftests/net/*timestamp* 21929 21932 F: tools/testing/selftests/net/so_txtime.c 21930 21933 21931 21934 SOEKRIS NET48XX LED SUPPORT
+4 -2
drivers/bluetooth/btusb.c
··· 2102 2102 return submit_or_queue_tx_urb(hdev, urb); 2103 2103 2104 2104 case HCI_SCODATA_PKT: 2105 - if (hci_conn_num(hdev, SCO_LINK) < 1) 2105 + if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 2106 + hci_conn_num(hdev, SCO_LINK) < 1) 2106 2107 return -ENODEV; 2107 2108 2108 2109 urb = alloc_isoc_urb(hdev, skb); ··· 2577 2576 return submit_or_queue_tx_urb(hdev, urb); 2578 2577 2579 2578 case HCI_SCODATA_PKT: 2580 - if (hci_conn_num(hdev, SCO_LINK) < 1) 2579 + if (!hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && 2580 + hci_conn_num(hdev, SCO_LINK) < 1) 2581 2581 return -ENODEV; 2582 2582 2583 2583 urb = alloc_isoc_urb(hdev, skb);
+6
drivers/net/dsa/realtek/Kconfig
··· 43 43 help 44 44 Select to enable support for Realtek RTL8366RB. 45 45 46 + config NET_DSA_REALTEK_RTL8366RB_LEDS 47 + bool "Support RTL8366RB LED control" 48 + depends on (LEDS_CLASS=y || LEDS_CLASS=NET_DSA_REALTEK_RTL8366RB) 49 + depends on NET_DSA_REALTEK_RTL8366RB 50 + default NET_DSA_REALTEK_RTL8366RB 51 + 46 52 endif
+3
drivers/net/dsa/realtek/Makefile
··· 12 12 13 13 obj-$(CONFIG_NET_DSA_REALTEK_RTL8366RB) += rtl8366.o 14 14 rtl8366-objs := rtl8366-core.o rtl8366rb.o 15 + ifdef CONFIG_NET_DSA_REALTEK_RTL8366RB_LEDS 16 + rtl8366-objs += rtl8366rb-leds.o 17 + endif 15 18 obj-$(CONFIG_NET_DSA_REALTEK_RTL8365MB) += rtl8365mb.o
+177
drivers/net/dsa/realtek/rtl8366rb-leds.c
··· 1 + // SPDX-License-Identifier: GPL-2.0 2 + 3 + #include <linux/bitops.h> 4 + #include <linux/regmap.h> 5 + #include <net/dsa.h> 6 + #include "rtl83xx.h" 7 + #include "rtl8366rb.h" 8 + 9 + static inline u32 rtl8366rb_led_group_port_mask(u8 led_group, u8 port) 10 + { 11 + switch (led_group) { 12 + case 0: 13 + return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 14 + case 1: 15 + return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 16 + case 2: 17 + return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 18 + case 3: 19 + return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 20 + default: 21 + return 0; 22 + } 23 + } 24 + 25 + static int rb8366rb_get_port_led(struct rtl8366rb_led *led) 26 + { 27 + struct realtek_priv *priv = led->priv; 28 + u8 led_group = led->led_group; 29 + u8 port_num = led->port_num; 30 + int ret; 31 + u32 val; 32 + 33 + ret = regmap_read(priv->map, RTL8366RB_LED_X_X_CTRL_REG(led_group), 34 + &val); 35 + if (ret) { 36 + dev_err(priv->dev, "error reading LED on port %d group %d\n", 37 + led_group, port_num); 38 + return ret; 39 + } 40 + 41 + return !!(val & rtl8366rb_led_group_port_mask(led_group, port_num)); 42 + } 43 + 44 + static int rb8366rb_set_port_led(struct rtl8366rb_led *led, bool enable) 45 + { 46 + struct realtek_priv *priv = led->priv; 47 + u8 led_group = led->led_group; 48 + u8 port_num = led->port_num; 49 + int ret; 50 + 51 + ret = regmap_update_bits(priv->map, 52 + RTL8366RB_LED_X_X_CTRL_REG(led_group), 53 + rtl8366rb_led_group_port_mask(led_group, 54 + port_num), 55 + enable ? 0xffff : 0); 56 + if (ret) { 57 + dev_err(priv->dev, "error updating LED on port %d group %d\n", 58 + led_group, port_num); 59 + return ret; 60 + } 61 + 62 + /* Change the LED group to manual controlled LEDs if required */ 63 + ret = rb8366rb_set_ledgroup_mode(priv, led_group, 64 + RTL8366RB_LEDGROUP_FORCE); 65 + 66 + if (ret) { 67 + dev_err(priv->dev, "error updating LED GROUP group %d\n", 68 + led_group); 69 + return ret; 70 + } 71 + 72 + return 0; 73 + } 74 + 75 + static int 76 + rtl8366rb_cled_brightness_set_blocking(struct led_classdev *ldev, 77 + enum led_brightness brightness) 78 + { 79 + struct rtl8366rb_led *led = container_of(ldev, struct rtl8366rb_led, 80 + cdev); 81 + 82 + return rb8366rb_set_port_led(led, brightness == LED_ON); 83 + } 84 + 85 + static int rtl8366rb_setup_led(struct realtek_priv *priv, struct dsa_port *dp, 86 + struct fwnode_handle *led_fwnode) 87 + { 88 + struct rtl8366rb *rb = priv->chip_data; 89 + struct led_init_data init_data = { }; 90 + enum led_default_state state; 91 + struct rtl8366rb_led *led; 92 + u32 led_group; 93 + int ret; 94 + 95 + ret = fwnode_property_read_u32(led_fwnode, "reg", &led_group); 96 + if (ret) 97 + return ret; 98 + 99 + if (led_group >= RTL8366RB_NUM_LEDGROUPS) { 100 + dev_warn(priv->dev, "Invalid LED reg %d defined for port %d", 101 + led_group, dp->index); 102 + return -EINVAL; 103 + } 104 + 105 + led = &rb->leds[dp->index][led_group]; 106 + led->port_num = dp->index; 107 + led->led_group = led_group; 108 + led->priv = priv; 109 + 110 + state = led_init_default_state_get(led_fwnode); 111 + switch (state) { 112 + case LEDS_DEFSTATE_ON: 113 + led->cdev.brightness = 1; 114 + rb8366rb_set_port_led(led, 1); 115 + break; 116 + case LEDS_DEFSTATE_KEEP: 117 + led->cdev.brightness = 118 + rb8366rb_get_port_led(led); 119 + break; 120 + case LEDS_DEFSTATE_OFF: 121 + default: 122 + led->cdev.brightness = 0; 123 + rb8366rb_set_port_led(led, 0); 124 + } 125 + 126 + led->cdev.max_brightness = 1; 127 + led->cdev.brightness_set_blocking = 128 + rtl8366rb_cled_brightness_set_blocking; 129 + init_data.fwnode = led_fwnode; 130 + init_data.devname_mandatory = true; 131 + 132 + init_data.devicename = kasprintf(GFP_KERNEL, "Realtek-%d:0%d:%d", 133 + dp->ds->index, dp->index, led_group); 134 + if (!init_data.devicename) 135 + return -ENOMEM; 136 + 137 + ret = devm_led_classdev_register_ext(priv->dev, &led->cdev, &init_data); 138 + if (ret) { 139 + dev_warn(priv->dev, "Failed to init LED %d for port %d", 140 + led_group, dp->index); 141 + return ret; 142 + } 143 + 144 + return 0; 145 + } 146 + 147 + int rtl8366rb_setup_leds(struct realtek_priv *priv) 148 + { 149 + struct dsa_switch *ds = &priv->ds; 150 + struct device_node *leds_np; 151 + struct dsa_port *dp; 152 + int ret = 0; 153 + 154 + dsa_switch_for_each_port(dp, ds) { 155 + if (!dp->dn) 156 + continue; 157 + 158 + leds_np = of_get_child_by_name(dp->dn, "leds"); 159 + if (!leds_np) { 160 + dev_dbg(priv->dev, "No leds defined for port %d", 161 + dp->index); 162 + continue; 163 + } 164 + 165 + for_each_child_of_node_scoped(leds_np, led_np) { 166 + ret = rtl8366rb_setup_led(priv, dp, 167 + of_fwnode_handle(led_np)); 168 + if (ret) 169 + break; 170 + } 171 + 172 + of_node_put(leds_np); 173 + if (ret) 174 + return ret; 175 + } 176 + return 0; 177 + }
+6 -252
drivers/net/dsa/realtek/rtl8366rb.c
··· 27 27 #include "realtek-smi.h" 28 28 #include "realtek-mdio.h" 29 29 #include "rtl83xx.h" 30 - 31 - #define RTL8366RB_PORT_NUM_CPU 5 32 - #define RTL8366RB_NUM_PORTS 6 33 - #define RTL8366RB_PHY_NO_MAX 4 34 - #define RTL8366RB_PHY_ADDR_MAX 31 30 + #include "rtl8366rb.h" 35 31 36 32 /* Switch Global Configuration register */ 37 33 #define RTL8366RB_SGCR 0x0000 ··· 172 176 */ 173 177 #define RTL8366RB_VLAN_INGRESS_CTRL2_REG 0x037f 174 178 175 - /* LED control registers */ 176 - /* The LED blink rate is global; it is used by all triggers in all groups. */ 177 - #define RTL8366RB_LED_BLINKRATE_REG 0x0430 178 - #define RTL8366RB_LED_BLINKRATE_MASK 0x0007 179 - #define RTL8366RB_LED_BLINKRATE_28MS 0x0000 180 - #define RTL8366RB_LED_BLINKRATE_56MS 0x0001 181 - #define RTL8366RB_LED_BLINKRATE_84MS 0x0002 182 - #define RTL8366RB_LED_BLINKRATE_111MS 0x0003 183 - #define RTL8366RB_LED_BLINKRATE_222MS 0x0004 184 - #define RTL8366RB_LED_BLINKRATE_446MS 0x0005 185 - 186 - /* LED trigger event for each group */ 187 - #define RTL8366RB_LED_CTRL_REG 0x0431 188 - #define RTL8366RB_LED_CTRL_OFFSET(led_group) \ 189 - (4 * (led_group)) 190 - #define RTL8366RB_LED_CTRL_MASK(led_group) \ 191 - (0xf << RTL8366RB_LED_CTRL_OFFSET(led_group)) 192 - 193 - /* The RTL8366RB_LED_X_X registers are used to manually set the LED state only 194 - * when the corresponding LED group in RTL8366RB_LED_CTRL_REG is 195 - * RTL8366RB_LEDGROUP_FORCE. Otherwise, it is ignored. 196 - */ 197 - #define RTL8366RB_LED_0_1_CTRL_REG 0x0432 198 - #define RTL8366RB_LED_2_3_CTRL_REG 0x0433 199 - #define RTL8366RB_LED_X_X_CTRL_REG(led_group) \ 200 - ((led_group) <= 1 ? \ 201 - RTL8366RB_LED_0_1_CTRL_REG : \ 202 - RTL8366RB_LED_2_3_CTRL_REG) 203 - #define RTL8366RB_LED_0_X_CTRL_MASK GENMASK(5, 0) 204 - #define RTL8366RB_LED_X_1_CTRL_MASK GENMASK(11, 6) 205 - #define RTL8366RB_LED_2_X_CTRL_MASK GENMASK(5, 0) 206 - #define RTL8366RB_LED_X_3_CTRL_MASK GENMASK(11, 6) 207 - 208 179 #define RTL8366RB_MIB_COUNT 33 209 180 #define RTL8366RB_GLOBAL_MIB_COUNT 1 210 181 #define RTL8366RB_MIB_COUNTER_PORT_OFFSET 0x0050 ··· 207 244 #define RTL8366RB_PORT_STATUS_AN_MASK 0x0080 208 245 209 246 #define RTL8366RB_NUM_VLANS 16 210 - #define RTL8366RB_NUM_LEDGROUPS 4 211 247 #define RTL8366RB_NUM_VIDS 4096 212 248 #define RTL8366RB_PRIORITYMAX 7 213 249 #define RTL8366RB_NUM_FIDS 8 ··· 312 350 #define RTL8366RB_GREEN_FEATURE_MSK 0x0007 313 351 #define RTL8366RB_GREEN_FEATURE_TX BIT(0) 314 352 #define RTL8366RB_GREEN_FEATURE_RX BIT(2) 315 - 316 - enum rtl8366_ledgroup_mode { 317 - RTL8366RB_LEDGROUP_OFF = 0x0, 318 - RTL8366RB_LEDGROUP_DUP_COL = 0x1, 319 - RTL8366RB_LEDGROUP_LINK_ACT = 0x2, 320 - RTL8366RB_LEDGROUP_SPD1000 = 0x3, 321 - RTL8366RB_LEDGROUP_SPD100 = 0x4, 322 - RTL8366RB_LEDGROUP_SPD10 = 0x5, 323 - RTL8366RB_LEDGROUP_SPD1000_ACT = 0x6, 324 - RTL8366RB_LEDGROUP_SPD100_ACT = 0x7, 325 - RTL8366RB_LEDGROUP_SPD10_ACT = 0x8, 326 - RTL8366RB_LEDGROUP_SPD100_10_ACT = 0x9, 327 - RTL8366RB_LEDGROUP_FIBER = 0xa, 328 - RTL8366RB_LEDGROUP_AN_FAULT = 0xb, 329 - RTL8366RB_LEDGROUP_LINK_RX = 0xc, 330 - RTL8366RB_LEDGROUP_LINK_TX = 0xd, 331 - RTL8366RB_LEDGROUP_MASTER = 0xe, 332 - RTL8366RB_LEDGROUP_FORCE = 0xf, 333 - 334 - __RTL8366RB_LEDGROUP_MODE_MAX 335 - }; 336 - 337 - struct rtl8366rb_led { 338 - u8 port_num; 339 - u8 led_group; 340 - struct realtek_priv *priv; 341 - struct led_classdev cdev; 342 - }; 343 - 344 - /** 345 - * struct rtl8366rb - RTL8366RB-specific data 346 - * @max_mtu: per-port max MTU setting 347 - * @pvid_enabled: if PVID is set for respective port 348 - * @leds: per-port and per-ledgroup led info 349 - */ 350 - struct rtl8366rb { 351 - unsigned int max_mtu[RTL8366RB_NUM_PORTS]; 352 - bool pvid_enabled[RTL8366RB_NUM_PORTS]; 353 - struct rtl8366rb_led leds[RTL8366RB_NUM_PORTS][RTL8366RB_NUM_LEDGROUPS]; 354 - }; 355 353 356 354 static struct rtl8366_mib_counter rtl8366rb_mib_counters[] = { 357 355 { 0, 0, 4, "IfInOctets" }, ··· 753 831 return 0; 754 832 } 755 833 756 - static int rb8366rb_set_ledgroup_mode(struct realtek_priv *priv, 757 - u8 led_group, 758 - enum rtl8366_ledgroup_mode mode) 834 + /* This code is used also with LEDs disabled */ 835 + int rb8366rb_set_ledgroup_mode(struct realtek_priv *priv, 836 + u8 led_group, 837 + enum rtl8366_ledgroup_mode mode) 759 838 { 760 839 int ret; 761 840 u32 val; ··· 773 850 return 0; 774 851 } 775 852 776 - static inline u32 rtl8366rb_led_group_port_mask(u8 led_group, u8 port) 777 - { 778 - switch (led_group) { 779 - case 0: 780 - return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 781 - case 1: 782 - return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 783 - case 2: 784 - return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 785 - case 3: 786 - return FIELD_PREP(RTL8366RB_LED_0_X_CTRL_MASK, BIT(port)); 787 - default: 788 - return 0; 789 - } 790 - } 791 - 792 - static int rb8366rb_get_port_led(struct rtl8366rb_led *led) 793 - { 794 - struct realtek_priv *priv = led->priv; 795 - u8 led_group = led->led_group; 796 - u8 port_num = led->port_num; 797 - int ret; 798 - u32 val; 799 - 800 - ret = regmap_read(priv->map, RTL8366RB_LED_X_X_CTRL_REG(led_group), 801 - &val); 802 - if (ret) { 803 - dev_err(priv->dev, "error reading LED on port %d group %d\n", 804 - led_group, port_num); 805 - return ret; 806 - } 807 - 808 - return !!(val & rtl8366rb_led_group_port_mask(led_group, port_num)); 809 - } 810 - 811 - static int rb8366rb_set_port_led(struct rtl8366rb_led *led, bool enable) 812 - { 813 - struct realtek_priv *priv = led->priv; 814 - u8 led_group = led->led_group; 815 - u8 port_num = led->port_num; 816 - int ret; 817 - 818 - ret = regmap_update_bits(priv->map, 819 - RTL8366RB_LED_X_X_CTRL_REG(led_group), 820 - rtl8366rb_led_group_port_mask(led_group, 821 - port_num), 822 - enable ? 0xffff : 0); 823 - if (ret) { 824 - dev_err(priv->dev, "error updating LED on port %d group %d\n", 825 - led_group, port_num); 826 - return ret; 827 - } 828 - 829 - /* Change the LED group to manual controlled LEDs if required */ 830 - ret = rb8366rb_set_ledgroup_mode(priv, led_group, 831 - RTL8366RB_LEDGROUP_FORCE); 832 - 833 - if (ret) { 834 - dev_err(priv->dev, "error updating LED GROUP group %d\n", 835 - led_group); 836 - return ret; 837 - } 838 - 839 - return 0; 840 - } 841 - 842 - static int 843 - rtl8366rb_cled_brightness_set_blocking(struct led_classdev *ldev, 844 - enum led_brightness brightness) 845 - { 846 - struct rtl8366rb_led *led = container_of(ldev, struct rtl8366rb_led, 847 - cdev); 848 - 849 - return rb8366rb_set_port_led(led, brightness == LED_ON); 850 - } 851 - 852 - static int rtl8366rb_setup_led(struct realtek_priv *priv, struct dsa_port *dp, 853 - struct fwnode_handle *led_fwnode) 854 - { 855 - struct rtl8366rb *rb = priv->chip_data; 856 - struct led_init_data init_data = { }; 857 - enum led_default_state state; 858 - struct rtl8366rb_led *led; 859 - u32 led_group; 860 - int ret; 861 - 862 - ret = fwnode_property_read_u32(led_fwnode, "reg", &led_group); 863 - if (ret) 864 - return ret; 865 - 866 - if (led_group >= RTL8366RB_NUM_LEDGROUPS) { 867 - dev_warn(priv->dev, "Invalid LED reg %d defined for port %d", 868 - led_group, dp->index); 869 - return -EINVAL; 870 - } 871 - 872 - led = &rb->leds[dp->index][led_group]; 873 - led->port_num = dp->index; 874 - led->led_group = led_group; 875 - led->priv = priv; 876 - 877 - state = led_init_default_state_get(led_fwnode); 878 - switch (state) { 879 - case LEDS_DEFSTATE_ON: 880 - led->cdev.brightness = 1; 881 - rb8366rb_set_port_led(led, 1); 882 - break; 883 - case LEDS_DEFSTATE_KEEP: 884 - led->cdev.brightness = 885 - rb8366rb_get_port_led(led); 886 - break; 887 - case LEDS_DEFSTATE_OFF: 888 - default: 889 - led->cdev.brightness = 0; 890 - rb8366rb_set_port_led(led, 0); 891 - } 892 - 893 - led->cdev.max_brightness = 1; 894 - led->cdev.brightness_set_blocking = 895 - rtl8366rb_cled_brightness_set_blocking; 896 - init_data.fwnode = led_fwnode; 897 - init_data.devname_mandatory = true; 898 - 899 - init_data.devicename = kasprintf(GFP_KERNEL, "Realtek-%d:0%d:%d", 900 - dp->ds->index, dp->index, led_group); 901 - if (!init_data.devicename) 902 - return -ENOMEM; 903 - 904 - ret = devm_led_classdev_register_ext(priv->dev, &led->cdev, &init_data); 905 - if (ret) { 906 - dev_warn(priv->dev, "Failed to init LED %d for port %d", 907 - led_group, dp->index); 908 - return ret; 909 - } 910 - 911 - return 0; 912 - } 913 - 853 + /* This code is used also with LEDs disabled */ 914 854 static int rtl8366rb_setup_all_leds_off(struct realtek_priv *priv) 915 855 { 916 856 int ret = 0; ··· 792 1006 } 793 1007 794 1008 return ret; 795 - } 796 - 797 - static int rtl8366rb_setup_leds(struct realtek_priv *priv) 798 - { 799 - struct dsa_switch *ds = &priv->ds; 800 - struct device_node *leds_np; 801 - struct dsa_port *dp; 802 - int ret = 0; 803 - 804 - dsa_switch_for_each_port(dp, ds) { 805 - if (!dp->dn) 806 - continue; 807 - 808 - leds_np = of_get_child_by_name(dp->dn, "leds"); 809 - if (!leds_np) { 810 - dev_dbg(priv->dev, "No leds defined for port %d", 811 - dp->index); 812 - continue; 813 - } 814 - 815 - for_each_child_of_node_scoped(leds_np, led_np) { 816 - ret = rtl8366rb_setup_led(priv, dp, 817 - of_fwnode_handle(led_np)); 818 - if (ret) 819 - break; 820 - } 821 - 822 - of_node_put(leds_np); 823 - if (ret) 824 - return ret; 825 - } 826 - return 0; 827 1009 } 828 1010 829 1011 static int rtl8366rb_setup(struct dsa_switch *ds)
+107
drivers/net/dsa/realtek/rtl8366rb.h
··· 1 + /* SPDX-License-Identifier: GPL-2.0+ */ 2 + 3 + #ifndef _RTL8366RB_H 4 + #define _RTL8366RB_H 5 + 6 + #include "realtek.h" 7 + 8 + #define RTL8366RB_PORT_NUM_CPU 5 9 + #define RTL8366RB_NUM_PORTS 6 10 + #define RTL8366RB_PHY_NO_MAX 4 11 + #define RTL8366RB_NUM_LEDGROUPS 4 12 + #define RTL8366RB_PHY_ADDR_MAX 31 13 + 14 + /* LED control registers */ 15 + /* The LED blink rate is global; it is used by all triggers in all groups. */ 16 + #define RTL8366RB_LED_BLINKRATE_REG 0x0430 17 + #define RTL8366RB_LED_BLINKRATE_MASK 0x0007 18 + #define RTL8366RB_LED_BLINKRATE_28MS 0x0000 19 + #define RTL8366RB_LED_BLINKRATE_56MS 0x0001 20 + #define RTL8366RB_LED_BLINKRATE_84MS 0x0002 21 + #define RTL8366RB_LED_BLINKRATE_111MS 0x0003 22 + #define RTL8366RB_LED_BLINKRATE_222MS 0x0004 23 + #define RTL8366RB_LED_BLINKRATE_446MS 0x0005 24 + 25 + /* LED trigger event for each group */ 26 + #define RTL8366RB_LED_CTRL_REG 0x0431 27 + #define RTL8366RB_LED_CTRL_OFFSET(led_group) \ 28 + (4 * (led_group)) 29 + #define RTL8366RB_LED_CTRL_MASK(led_group) \ 30 + (0xf << RTL8366RB_LED_CTRL_OFFSET(led_group)) 31 + 32 + /* The RTL8366RB_LED_X_X registers are used to manually set the LED state only 33 + * when the corresponding LED group in RTL8366RB_LED_CTRL_REG is 34 + * RTL8366RB_LEDGROUP_FORCE. Otherwise, it is ignored. 35 + */ 36 + #define RTL8366RB_LED_0_1_CTRL_REG 0x0432 37 + #define RTL8366RB_LED_2_3_CTRL_REG 0x0433 38 + #define RTL8366RB_LED_X_X_CTRL_REG(led_group) \ 39 + ((led_group) <= 1 ? \ 40 + RTL8366RB_LED_0_1_CTRL_REG : \ 41 + RTL8366RB_LED_2_3_CTRL_REG) 42 + #define RTL8366RB_LED_0_X_CTRL_MASK GENMASK(5, 0) 43 + #define RTL8366RB_LED_X_1_CTRL_MASK GENMASK(11, 6) 44 + #define RTL8366RB_LED_2_X_CTRL_MASK GENMASK(5, 0) 45 + #define RTL8366RB_LED_X_3_CTRL_MASK GENMASK(11, 6) 46 + 47 + enum rtl8366_ledgroup_mode { 48 + RTL8366RB_LEDGROUP_OFF = 0x0, 49 + RTL8366RB_LEDGROUP_DUP_COL = 0x1, 50 + RTL8366RB_LEDGROUP_LINK_ACT = 0x2, 51 + RTL8366RB_LEDGROUP_SPD1000 = 0x3, 52 + RTL8366RB_LEDGROUP_SPD100 = 0x4, 53 + RTL8366RB_LEDGROUP_SPD10 = 0x5, 54 + RTL8366RB_LEDGROUP_SPD1000_ACT = 0x6, 55 + RTL8366RB_LEDGROUP_SPD100_ACT = 0x7, 56 + RTL8366RB_LEDGROUP_SPD10_ACT = 0x8, 57 + RTL8366RB_LEDGROUP_SPD100_10_ACT = 0x9, 58 + RTL8366RB_LEDGROUP_FIBER = 0xa, 59 + RTL8366RB_LEDGROUP_AN_FAULT = 0xb, 60 + RTL8366RB_LEDGROUP_LINK_RX = 0xc, 61 + RTL8366RB_LEDGROUP_LINK_TX = 0xd, 62 + RTL8366RB_LEDGROUP_MASTER = 0xe, 63 + RTL8366RB_LEDGROUP_FORCE = 0xf, 64 + 65 + __RTL8366RB_LEDGROUP_MODE_MAX 66 + }; 67 + 68 + #if IS_ENABLED(CONFIG_NET_DSA_REALTEK_RTL8366RB_LEDS) 69 + 70 + struct rtl8366rb_led { 71 + u8 port_num; 72 + u8 led_group; 73 + struct realtek_priv *priv; 74 + struct led_classdev cdev; 75 + }; 76 + 77 + int rtl8366rb_setup_leds(struct realtek_priv *priv); 78 + 79 + #else 80 + 81 + static inline int rtl8366rb_setup_leds(struct realtek_priv *priv) 82 + { 83 + return 0; 84 + } 85 + 86 + #endif /* IS_ENABLED(CONFIG_LEDS_CLASS) */ 87 + 88 + /** 89 + * struct rtl8366rb - RTL8366RB-specific data 90 + * @max_mtu: per-port max MTU setting 91 + * @pvid_enabled: if PVID is set for respective port 92 + * @leds: per-port and per-ledgroup led info 93 + */ 94 + struct rtl8366rb { 95 + unsigned int max_mtu[RTL8366RB_NUM_PORTS]; 96 + bool pvid_enabled[RTL8366RB_NUM_PORTS]; 97 + #if IS_ENABLED(CONFIG_NET_DSA_REALTEK_RTL8366RB_LEDS) 98 + struct rtl8366rb_led leds[RTL8366RB_NUM_PORTS][RTL8366RB_NUM_LEDGROUPS]; 99 + #endif 100 + }; 101 + 102 + /* This code is used also with LEDs disabled */ 103 + int rb8366rb_set_ledgroup_mode(struct realtek_priv *priv, 104 + u8 led_group, 105 + enum rtl8366_ledgroup_mode mode); 106 + 107 + #endif /* _RTL8366RB_H */
+2
drivers/net/ethernet/cadence/macb.h
··· 1279 1279 struct clk *rx_clk; 1280 1280 struct clk *tsu_clk; 1281 1281 struct net_device *dev; 1282 + /* Protects hw_stats and ethtool_stats */ 1283 + spinlock_t stats_lock; 1282 1284 union { 1283 1285 struct macb_stats macb; 1284 1286 struct gem_stats gem;
+10 -2
drivers/net/ethernet/cadence/macb_main.c
··· 1978 1978 1979 1979 if (status & MACB_BIT(ISR_ROVR)) { 1980 1980 /* We missed at least one packet */ 1981 + spin_lock(&bp->stats_lock); 1981 1982 if (macb_is_gem(bp)) 1982 1983 bp->hw_stats.gem.rx_overruns++; 1983 1984 else 1984 1985 bp->hw_stats.macb.rx_overruns++; 1986 + spin_unlock(&bp->stats_lock); 1985 1987 1986 1988 if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE) 1987 1989 queue_writel(queue, ISR, MACB_BIT(ISR_ROVR)); ··· 3104 3102 if (!netif_running(bp->dev)) 3105 3103 return nstat; 3106 3104 3105 + spin_lock_irq(&bp->stats_lock); 3107 3106 gem_update_stats(bp); 3108 3107 3109 3108 nstat->rx_errors = (hwstat->rx_frame_check_sequence_errors + ··· 3134 3131 nstat->tx_aborted_errors = hwstat->tx_excessive_collisions; 3135 3132 nstat->tx_carrier_errors = hwstat->tx_carrier_sense_errors; 3136 3133 nstat->tx_fifo_errors = hwstat->tx_underrun; 3134 + spin_unlock_irq(&bp->stats_lock); 3137 3135 3138 3136 return nstat; 3139 3137 } ··· 3142 3138 static void gem_get_ethtool_stats(struct net_device *dev, 3143 3139 struct ethtool_stats *stats, u64 *data) 3144 3140 { 3145 - struct macb *bp; 3141 + struct macb *bp = netdev_priv(dev); 3146 3142 3147 - bp = netdev_priv(dev); 3143 + spin_lock_irq(&bp->stats_lock); 3148 3144 gem_update_stats(bp); 3149 3145 memcpy(data, &bp->ethtool_stats, sizeof(u64) 3150 3146 * (GEM_STATS_LEN + QUEUE_STATS_LEN * MACB_MAX_QUEUES)); 3147 + spin_unlock_irq(&bp->stats_lock); 3151 3148 } 3152 3149 3153 3150 static int gem_get_sset_count(struct net_device *dev, int sset) ··· 3198 3193 return gem_get_stats(bp); 3199 3194 3200 3195 /* read stats from hardware */ 3196 + spin_lock_irq(&bp->stats_lock); 3201 3197 macb_update_stats(bp); 3202 3198 3203 3199 /* Convert HW stats into netdevice stats */ ··· 3232 3226 nstat->tx_carrier_errors = hwstat->tx_carrier_errors; 3233 3227 nstat->tx_fifo_errors = hwstat->tx_underruns; 3234 3228 /* Don't know about heartbeat or window errors... */ 3229 + spin_unlock_irq(&bp->stats_lock); 3235 3230 3236 3231 return nstat; 3237 3232 } ··· 5104 5097 } 5105 5098 } 5106 5099 spin_lock_init(&bp->lock); 5100 + spin_lock_init(&bp->stats_lock); 5107 5101 5108 5102 /* setup capabilities */ 5109 5103 macb_configure_caps(bp, macb_config);
+74 -29
drivers/net/ethernet/freescale/enetc/enetc.c
··· 167 167 return skb->csum_offset == offsetof(struct tcphdr, check); 168 168 } 169 169 170 + /** 171 + * enetc_unwind_tx_frame() - Unwind the DMA mappings of a multi-buffer Tx frame 172 + * @tx_ring: Pointer to the Tx ring on which the buffer descriptors are located 173 + * @count: Number of Tx buffer descriptors which need to be unmapped 174 + * @i: Index of the last successfully mapped Tx buffer descriptor 175 + */ 176 + static void enetc_unwind_tx_frame(struct enetc_bdr *tx_ring, int count, int i) 177 + { 178 + while (count--) { 179 + struct enetc_tx_swbd *tx_swbd = &tx_ring->tx_swbd[i]; 180 + 181 + enetc_free_tx_frame(tx_ring, tx_swbd); 182 + if (i == 0) 183 + i = tx_ring->bd_count; 184 + i--; 185 + } 186 + } 187 + 170 188 static int enetc_map_tx_buffs(struct enetc_bdr *tx_ring, struct sk_buff *skb) 171 189 { 172 190 bool do_vlan, do_onestep_tstamp = false, do_twostep_tstamp = false; ··· 297 279 } 298 280 299 281 if (do_onestep_tstamp) { 300 - u32 lo, hi, val; 301 - u64 sec, nsec; 282 + __be32 new_sec_l, new_nsec; 283 + u32 lo, hi, nsec, val; 284 + __be16 new_sec_h; 302 285 u8 *data; 286 + u64 sec; 303 287 304 288 lo = enetc_rd_hot(hw, ENETC_SICTR0); 305 289 hi = enetc_rd_hot(hw, ENETC_SICTR1); ··· 315 295 /* Update originTimestamp field of Sync packet 316 296 * - 48 bits seconds field 317 297 * - 32 bits nanseconds field 298 + * 299 + * In addition, the UDP checksum needs to be updated 300 + * by software after updating originTimestamp field, 301 + * otherwise the hardware will calculate the wrong 302 + * checksum when updating the correction field and 303 + * update it to the packet. 318 304 */ 319 305 data = skb_mac_header(skb); 320 - *(__be16 *)(data + offset2) = 321 - htons((sec >> 32) & 0xffff); 322 - *(__be32 *)(data + offset2 + 2) = 323 - htonl(sec & 0xffffffff); 324 - *(__be32 *)(data + offset2 + 6) = htonl(nsec); 306 + new_sec_h = htons((sec >> 32) & 0xffff); 307 + new_sec_l = htonl(sec & 0xffffffff); 308 + new_nsec = htonl(nsec); 309 + if (udp) { 310 + struct udphdr *uh = udp_hdr(skb); 311 + __be32 old_sec_l, old_nsec; 312 + __be16 old_sec_h; 313 + 314 + old_sec_h = *(__be16 *)(data + offset2); 315 + inet_proto_csum_replace2(&uh->check, skb, old_sec_h, 316 + new_sec_h, false); 317 + 318 + old_sec_l = *(__be32 *)(data + offset2 + 2); 319 + inet_proto_csum_replace4(&uh->check, skb, old_sec_l, 320 + new_sec_l, false); 321 + 322 + old_nsec = *(__be32 *)(data + offset2 + 6); 323 + inet_proto_csum_replace4(&uh->check, skb, old_nsec, 324 + new_nsec, false); 325 + } 326 + 327 + *(__be16 *)(data + offset2) = new_sec_h; 328 + *(__be32 *)(data + offset2 + 2) = new_sec_l; 329 + *(__be32 *)(data + offset2 + 6) = new_nsec; 325 330 326 331 /* Configure single-step register */ 327 332 val = ENETC_PM0_SINGLE_STEP_EN; ··· 417 372 dma_err: 418 373 dev_err(tx_ring->dev, "DMA map error"); 419 374 420 - do { 421 - tx_swbd = &tx_ring->tx_swbd[i]; 422 - enetc_free_tx_frame(tx_ring, tx_swbd); 423 - if (i == 0) 424 - i = tx_ring->bd_count; 425 - i--; 426 - } while (count--); 375 + enetc_unwind_tx_frame(tx_ring, count, i); 427 376 428 377 return 0; 429 378 } 430 379 431 - static void enetc_map_tx_tso_hdr(struct enetc_bdr *tx_ring, struct sk_buff *skb, 432 - struct enetc_tx_swbd *tx_swbd, 433 - union enetc_tx_bd *txbd, int *i, int hdr_len, 434 - int data_len) 380 + static int enetc_map_tx_tso_hdr(struct enetc_bdr *tx_ring, struct sk_buff *skb, 381 + struct enetc_tx_swbd *tx_swbd, 382 + union enetc_tx_bd *txbd, int *i, int hdr_len, 383 + int data_len) 435 384 { 436 385 union enetc_tx_bd txbd_tmp; 437 386 u8 flags = 0, e_flags = 0; 438 387 dma_addr_t addr; 388 + int count = 1; 439 389 440 390 enetc_clear_tx_bd(&txbd_tmp); 441 391 addr = tx_ring->tso_headers_dma + *i * TSO_HEADER_SIZE; ··· 473 433 /* Write the BD */ 474 434 txbd_tmp.ext.e_flags = e_flags; 475 435 *txbd = txbd_tmp; 436 + count++; 476 437 } 438 + 439 + return count; 477 440 } 478 441 479 442 static int enetc_map_tx_tso_data(struct enetc_bdr *tx_ring, struct sk_buff *skb, ··· 833 790 834 791 /* compute the csum over the L4 header */ 835 792 csum = enetc_tso_hdr_csum(&tso, skb, hdr, hdr_len, &pos); 836 - enetc_map_tx_tso_hdr(tx_ring, skb, tx_swbd, txbd, &i, hdr_len, data_len); 793 + count += enetc_map_tx_tso_hdr(tx_ring, skb, tx_swbd, txbd, 794 + &i, hdr_len, data_len); 837 795 bd_data_num = 0; 838 - count++; 839 796 840 797 while (data_len > 0) { 841 798 int size; ··· 859 816 err = enetc_map_tx_tso_data(tx_ring, skb, tx_swbd, txbd, 860 817 tso.data, size, 861 818 size == data_len); 862 - if (err) 819 + if (err) { 820 + if (i == 0) 821 + i = tx_ring->bd_count; 822 + i--; 823 + 863 824 goto err_map_data; 825 + } 864 826 865 827 data_len -= size; 866 828 count++; ··· 894 846 dev_err(tx_ring->dev, "DMA map error"); 895 847 896 848 err_chained_bd: 897 - do { 898 - tx_swbd = &tx_ring->tx_swbd[i]; 899 - enetc_free_tx_frame(tx_ring, tx_swbd); 900 - if (i == 0) 901 - i = tx_ring->bd_count; 902 - i--; 903 - } while (count--); 849 + enetc_unwind_tx_frame(tx_ring, count, i); 904 850 905 851 return 0; 906 852 } ··· 1943 1901 enetc_xdp_drop(rx_ring, orig_i, i); 1944 1902 tx_ring->stats.xdp_tx_drops++; 1945 1903 } else { 1946 - tx_ring->stats.xdp_tx += xdp_tx_bd_cnt; 1904 + tx_ring->stats.xdp_tx++; 1947 1905 rx_ring->xdp.xdp_tx_in_flight += xdp_tx_bd_cnt; 1948 1906 xdp_tx_frm_cnt++; 1949 1907 /* The XDP_TX enqueue was successful, so we ··· 3270 3228 new_offloads |= ENETC_F_TX_TSTAMP; 3271 3229 break; 3272 3230 case HWTSTAMP_TX_ONESTEP_SYNC: 3231 + if (!enetc_si_is_pf(priv->si)) 3232 + return -EOPNOTSUPP; 3233 + 3273 3234 new_offloads &= ~ENETC_F_TX_TSTAMP_MASK; 3274 3235 new_offloads |= ENETC_F_TX_ONESTEP_SYNC_TSTAMP; 3275 3236 break;
+1 -1
drivers/net/ethernet/freescale/enetc/enetc4_pf.c
··· 672 672 err_alloc_msix: 673 673 err_config_si: 674 674 err_clk_get: 675 - mutex_destroy(&priv->mm_lock); 676 675 free_netdev(ndev); 677 676 678 677 return err; ··· 683 684 struct net_device *ndev = si->ndev; 684 685 685 686 unregister_netdev(ndev); 687 + enetc4_link_deinit(priv); 686 688 enetc_free_msix(priv); 687 689 free_netdev(ndev); 688 690 }
+5 -2
drivers/net/ethernet/freescale/enetc/enetc_ethtool.c
··· 832 832 static int enetc_get_ts_info(struct net_device *ndev, 833 833 struct kernel_ethtool_ts_info *info) 834 834 { 835 + struct enetc_ndev_priv *priv = netdev_priv(ndev); 835 836 int *phc_idx; 836 837 837 838 phc_idx = symbol_get(enetc_phc_index); ··· 853 852 SOF_TIMESTAMPING_TX_SOFTWARE; 854 853 855 854 info->tx_types = (1 << HWTSTAMP_TX_OFF) | 856 - (1 << HWTSTAMP_TX_ON) | 857 - (1 << HWTSTAMP_TX_ONESTEP_SYNC); 855 + (1 << HWTSTAMP_TX_ON); 856 + 857 + if (enetc_si_is_pf(priv->si)) 858 + info->tx_types |= (1 << HWTSTAMP_TX_ONESTEP_SYNC); 858 859 859 860 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) | 860 861 (1 << HWTSTAMP_FILTER_ALL);
+2
drivers/net/ethernet/google/gve/gve_rx_dqo.c
··· 109 109 void gve_rx_stop_ring_dqo(struct gve_priv *priv, int idx) 110 110 { 111 111 int ntfy_idx = gve_rx_idx_to_ntfy(priv, idx); 112 + struct gve_rx_ring *rx = &priv->rx[idx]; 112 113 113 114 if (!gve_rx_was_added_to_block(priv, idx)) 114 115 return; 115 116 117 + page_pool_disable_direct_recycling(rx->dqo.page_pool); 116 118 gve_remove_napi(priv, ntfy_idx); 117 119 gve_rx_remove_from_block(priv, idx); 118 120 gve_rx_reset_ring_dqo(priv, idx);
+8 -4
drivers/net/ethernet/intel/iavf/iavf_main.c
··· 1983 1983 static void iavf_finish_config(struct work_struct *work) 1984 1984 { 1985 1985 struct iavf_adapter *adapter; 1986 - bool netdev_released = false; 1986 + bool locks_released = false; 1987 1987 int pairs, err; 1988 1988 1989 1989 adapter = container_of(work, struct iavf_adapter, finish_config); ··· 2012 2012 netif_set_real_num_tx_queues(adapter->netdev, pairs); 2013 2013 2014 2014 if (adapter->netdev->reg_state != NETREG_REGISTERED) { 2015 + mutex_unlock(&adapter->crit_lock); 2015 2016 netdev_unlock(adapter->netdev); 2016 - netdev_released = true; 2017 + locks_released = true; 2017 2018 err = register_netdevice(adapter->netdev); 2018 2019 if (err) { 2019 2020 dev_err(&adapter->pdev->dev, "Unable to register netdev (%d)\n", 2020 2021 err); 2021 2022 2022 2023 /* go back and try again.*/ 2024 + mutex_lock(&adapter->crit_lock); 2023 2025 iavf_free_rss(adapter); 2024 2026 iavf_free_misc_irq(adapter); 2025 2027 iavf_reset_interrupt_capability(adapter); 2026 2028 iavf_change_state(adapter, 2027 2029 __IAVF_INIT_CONFIG_ADAPTER); 2030 + mutex_unlock(&adapter->crit_lock); 2028 2031 goto out; 2029 2032 } 2030 2033 } ··· 2043 2040 } 2044 2041 2045 2042 out: 2046 - mutex_unlock(&adapter->crit_lock); 2047 - if (!netdev_released) 2043 + if (!locks_released) { 2044 + mutex_unlock(&adapter->crit_lock); 2048 2045 netdev_unlock(adapter->netdev); 2046 + } 2049 2047 rtnl_unlock(); 2050 2048 } 2051 2049
+1 -2
drivers/net/ethernet/intel/ice/ice_eswitch.c
··· 38 38 if (ice_vsi_add_vlan_zero(uplink_vsi)) 39 39 goto err_vlan_zero; 40 40 41 - if (ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, true, 42 - ICE_FLTR_RX)) 41 + if (ice_set_dflt_vsi(uplink_vsi)) 43 42 goto err_def_rx; 44 43 45 44 if (ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, true,
+1 -4
drivers/net/ethernet/intel/ice/ice_sriov.c
··· 36 36 37 37 hash_for_each_safe(vfs->table, bkt, tmp, vf, entry) { 38 38 hash_del_rcu(&vf->entry); 39 + ice_deinitialize_vf_entry(vf); 39 40 ice_put_vf(vf); 40 41 } 41 42 } ··· 193 192 bit_idx = (hw->func_caps.vf_base_id + vf->vf_id) % 32; 194 193 wr32(hw, GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx)); 195 194 } 196 - 197 - /* clear malicious info since the VF is getting released */ 198 - if (!ice_is_feature_supported(pf, ICE_F_MBX_LIMIT)) 199 - list_del(&vf->mbx_info.list_entry); 200 195 201 196 mutex_unlock(&vf->cfg_lock); 202 197 }
+8
drivers/net/ethernet/intel/ice/ice_vf_lib.c
··· 1036 1036 mutex_init(&vf->cfg_lock); 1037 1037 } 1038 1038 1039 + void ice_deinitialize_vf_entry(struct ice_vf *vf) 1040 + { 1041 + struct ice_pf *pf = vf->pf; 1042 + 1043 + if (!ice_is_feature_supported(pf, ICE_F_MBX_LIMIT)) 1044 + list_del(&vf->mbx_info.list_entry); 1045 + } 1046 + 1039 1047 /** 1040 1048 * ice_dis_vf_qs - Disable the VF queues 1041 1049 * @vf: pointer to the VF structure
+1
drivers/net/ethernet/intel/ice/ice_vf_lib_private.h
··· 24 24 #endif 25 25 26 26 void ice_initialize_vf_entry(struct ice_vf *vf); 27 + void ice_deinitialize_vf_entry(struct ice_vf *vf); 27 28 void ice_dis_vf_qs(struct ice_vf *vf); 28 29 int ice_check_vf_init(struct ice_vf *vf); 29 30 enum virtchnl_status_code ice_err_to_virt_err(int err);
+2 -1
drivers/net/ethernet/intel/idpf/idpf_txrx.c
··· 3013 3013 skb_shinfo(skb)->gso_size = rsc_seg_len; 3014 3014 3015 3015 skb_reset_network_header(skb); 3016 - len = skb->len - skb_transport_offset(skb); 3017 3016 3018 3017 if (ipv4) { 3019 3018 struct iphdr *ipv4h = ip_hdr(skb); ··· 3021 3022 3022 3023 /* Reset and set transport header offset in skb */ 3023 3024 skb_set_transport_header(skb, sizeof(struct iphdr)); 3025 + len = skb->len - skb_transport_offset(skb); 3024 3026 3025 3027 /* Compute the TCP pseudo header checksum*/ 3026 3028 tcp_hdr(skb)->check = ··· 3031 3031 3032 3032 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6; 3033 3033 skb_set_transport_header(skb, sizeof(struct ipv6hdr)); 3034 + len = skb->len - skb_transport_offset(skb); 3034 3035 tcp_hdr(skb)->check = 3035 3036 ~tcp_v6_check(len, &ipv6h->saddr, &ipv6h->daddr, 0); 3036 3037 }
+1 -1
drivers/net/ethernet/intel/ixgbe/ixgbe_e610.c
··· 1122 1122 * returns error (ENOENT), then no cage present. If no cage present then 1123 1123 * connection type is backplane or BASE-T. 1124 1124 */ 1125 - return ixgbe_aci_get_netlist_node(hw, cmd, NULL, NULL); 1125 + return !ixgbe_aci_get_netlist_node(hw, cmd, NULL, NULL); 1126 1126 } 1127 1127 1128 1128 /**
+1 -1
drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c
··· 324 324 MVPP2_PRS_RI_VLAN_MASK), 325 325 /* Non IP flow, with vlan tag */ 326 326 MVPP2_DEF_FLOW(MVPP22_FLOW_ETHERNET, MVPP2_FL_NON_IP_TAG, 327 - MVPP22_CLS_HEK_OPT_VLAN, 327 + MVPP22_CLS_HEK_TAGGED, 328 328 0, 0), 329 329 }; 330 330
+7 -1
drivers/net/ethernet/mellanox/mlx5/core/esw/qos.c
··· 564 564 return err; 565 565 566 566 esw_qos_normalize_min_rate(parent->esw, parent, extack); 567 + trace_mlx5_esw_vport_qos_create(vport->dev, vport, 568 + vport->qos.sched_node->max_rate, 569 + vport->qos.sched_node->bw_share); 567 570 568 571 return 0; 569 572 } ··· 594 591 sched_node->vport = vport; 595 592 vport->qos.sched_node = sched_node; 596 593 err = esw_qos_vport_enable(vport, parent, extack); 597 - if (err) 594 + if (err) { 595 + __esw_qos_free_node(sched_node); 598 596 esw_qos_put(esw); 597 + vport->qos.sched_node = NULL; 598 + } 599 599 600 600 return err; 601 601 }
+1 -1
drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c
··· 572 572 pool->min_threshold = min_threshold * MLX5_EQ_REFS_PER_IRQ; 573 573 pool->max_threshold = max_threshold * MLX5_EQ_REFS_PER_IRQ; 574 574 mlx5_core_dbg(dev, "pool->name = %s, pool->size = %d, pool->start = %d", 575 - name, size, start); 575 + name ? name : "mlx5_pcif_pool", size, start); 576 576 return pool; 577 577 } 578 578
+14
drivers/net/ethernet/stmicro/stmmac/dwmac-loongson.c
··· 516 516 return 0; 517 517 } 518 518 519 + /* Loongson's DWMAC device may take nearly two seconds to complete DMA reset */ 520 + static int loongson_dwmac_fix_reset(void *priv, void __iomem *ioaddr) 521 + { 522 + u32 value = readl(ioaddr + DMA_BUS_MODE); 523 + 524 + value |= DMA_BUS_MODE_SFT_RESET; 525 + writel(value, ioaddr + DMA_BUS_MODE); 526 + 527 + return readl_poll_timeout(ioaddr + DMA_BUS_MODE, value, 528 + !(value & DMA_BUS_MODE_SFT_RESET), 529 + 10000, 2000000); 530 + } 531 + 519 532 static int loongson_dwmac_probe(struct pci_dev *pdev, const struct pci_device_id *id) 520 533 { 521 534 struct plat_stmmacenet_data *plat; ··· 579 566 580 567 plat->bsp_priv = ld; 581 568 plat->setup = loongson_dwmac_setup; 569 + plat->fix_soc_reset = loongson_dwmac_fix_reset; 582 570 ld->dev = &pdev->dev; 583 571 ld->loongson_id = readl(res.addr + GMAC_VERSION) & 0xff; 584 572
+1
drivers/net/ethernet/ti/Kconfig
··· 99 99 select NET_DEVLINK 100 100 select TI_DAVINCI_MDIO 101 101 select PHYLINK 102 + select PAGE_POOL 102 103 select TI_K3_CPPI_DESC_POOL 103 104 imply PHY_TI_GMII_SEL 104 105 depends on TI_K3_AM65_CPTS || !TI_K3_AM65_CPTS
+1 -20
drivers/net/ethernet/ti/icssg/icss_iep.c
··· 474 474 static int icss_iep_perout_enable(struct icss_iep *iep, 475 475 struct ptp_perout_request *req, int on) 476 476 { 477 - int ret = 0; 478 - 479 - mutex_lock(&iep->ptp_clk_mutex); 480 - 481 - if (iep->pps_enabled) { 482 - ret = -EBUSY; 483 - goto exit; 484 - } 485 - 486 - if (iep->perout_enabled == !!on) 487 - goto exit; 488 - 489 - ret = icss_iep_perout_enable_hw(iep, req, on); 490 - if (!ret) 491 - iep->perout_enabled = !!on; 492 - 493 - exit: 494 - mutex_unlock(&iep->ptp_clk_mutex); 495 - 496 - return ret; 477 + return -EOPNOTSUPP; 497 478 } 498 479 499 480 static void icss_iep_cap_cmp_work(struct work_struct *work)
+16 -5
drivers/net/ipvlan/ipvlan_core.c
··· 416 416 417 417 static noinline_for_stack int ipvlan_process_v4_outbound(struct sk_buff *skb) 418 418 { 419 - const struct iphdr *ip4h = ip_hdr(skb); 420 419 struct net_device *dev = skb->dev; 421 420 struct net *net = dev_net(dev); 422 - struct rtable *rt; 423 421 int err, ret = NET_XMIT_DROP; 422 + const struct iphdr *ip4h; 423 + struct rtable *rt; 424 424 struct flowi4 fl4 = { 425 425 .flowi4_oif = dev->ifindex, 426 - .flowi4_tos = inet_dscp_to_dsfield(ip4h_dscp(ip4h)), 427 426 .flowi4_flags = FLOWI_FLAG_ANYSRC, 428 427 .flowi4_mark = skb->mark, 429 - .daddr = ip4h->daddr, 430 - .saddr = ip4h->saddr, 431 428 }; 429 + 430 + if (!pskb_network_may_pull(skb, sizeof(struct iphdr))) 431 + goto err; 432 + 433 + ip4h = ip_hdr(skb); 434 + fl4.daddr = ip4h->daddr; 435 + fl4.saddr = ip4h->saddr; 436 + fl4.flowi4_tos = inet_dscp_to_dsfield(ip4h_dscp(ip4h)); 432 437 433 438 rt = ip_route_output_flow(net, &fl4, NULL); 434 439 if (IS_ERR(rt)) ··· 492 487 { 493 488 struct net_device *dev = skb->dev; 494 489 int err, ret = NET_XMIT_DROP; 490 + 491 + if (!pskb_network_may_pull(skb, sizeof(struct ipv6hdr))) { 492 + DEV_STATS_INC(dev, tx_errors); 493 + kfree_skb(skb); 494 + return ret; 495 + } 495 496 496 497 err = ipvlan_route_v6_outbound(dev, skb); 497 498 if (unlikely(err)) {
+14
drivers/net/loopback.c
··· 244 244 return NETDEV_TX_OK; 245 245 } 246 246 247 + static int blackhole_neigh_output(struct neighbour *n, struct sk_buff *skb) 248 + { 249 + kfree_skb(skb); 250 + return 0; 251 + } 252 + 253 + static int blackhole_neigh_construct(struct net_device *dev, 254 + struct neighbour *n) 255 + { 256 + n->output = blackhole_neigh_output; 257 + return 0; 258 + } 259 + 247 260 static const struct net_device_ops blackhole_netdev_ops = { 248 261 .ndo_start_xmit = blackhole_netdev_xmit, 262 + .ndo_neigh_construct = blackhole_neigh_construct, 249 263 }; 250 264 251 265 /* This is a dst-dummy device used specifically for invalidated
+2
drivers/net/netdevsim/ethtool.c
··· 184 184 185 185 static void nsim_ethtool_ring_init(struct netdevsim *ns) 186 186 { 187 + ns->ethtool.ring.rx_pending = 512; 187 188 ns->ethtool.ring.rx_max_pending = 4096; 188 189 ns->ethtool.ring.rx_jumbo_max_pending = 4096; 189 190 ns->ethtool.ring.rx_mini_max_pending = 4096; 191 + ns->ethtool.ring.tx_pending = 512; 190 192 ns->ethtool.ring.tx_max_pending = 4096; 191 193 } 192 194
+1 -1
drivers/net/phy/qcom/qca807x.c
··· 774 774 control_dac &= ~QCA807X_CONTROL_DAC_MASK; 775 775 if (!priv->dac_full_amplitude) 776 776 control_dac |= QCA807X_CONTROL_DAC_DSP_AMPLITUDE; 777 - if (!priv->dac_full_amplitude) 777 + if (!priv->dac_full_bias_current) 778 778 control_dac |= QCA807X_CONTROL_DAC_DSP_BIAS_CURRENT; 779 779 if (!priv->dac_disable_bias_current_tweak) 780 780 control_dac |= QCA807X_CONTROL_DAC_BIAS_CURRENT_TWEAK;
+1 -3
drivers/net/usb/gl620a.c
··· 179 179 { 180 180 dev->hard_mtu = GL_RCV_BUF_SIZE; 181 181 dev->net->hard_header_len += 4; 182 - dev->in = usb_rcvbulkpipe(dev->udev, dev->driver_info->in); 183 - dev->out = usb_sndbulkpipe(dev->udev, dev->driver_info->out); 184 - return 0; 182 + return usbnet_get_endpoints(dev, intf); 185 183 } 186 184 187 185 static const struct driver_info genelink_info = {
+3
fs/afs/server.c
··· 163 163 rb_insert_color(&server->uuid_rb, &net->fs_servers); 164 164 hlist_add_head_rcu(&server->proc_link, &net->fs_proc); 165 165 166 + afs_get_cell(cell, afs_cell_trace_get_server); 167 + 166 168 added_dup: 167 169 write_seqlock(&net->fs_addr_lock); 168 170 estate = rcu_dereference_protected(server->endpoint_state, ··· 444 442 atomic_read(&server->active), afs_server_trace_free); 445 443 afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state), 446 444 afs_estate_trace_put_server); 445 + afs_put_cell(server->cell, afs_cell_trace_put_server); 447 446 kfree(server); 448 447 } 449 448
+2 -2
fs/afs/server_list.c
··· 97 97 break; 98 98 if (j < slist->nr_servers) { 99 99 if (slist->servers[j].server == server) { 100 - afs_put_server(volume->cell->net, server, 101 - afs_server_trace_put_slist_isort); 100 + afs_unuse_server(volume->cell->net, server, 101 + afs_server_trace_put_slist_isort); 102 102 continue; 103 103 } 104 104
+2
include/linux/socket.h
··· 392 392 393 393 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr); 394 394 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data); 395 + extern int put_cmsg_notrunc(struct msghdr *msg, int level, int type, int len, 396 + void *data); 395 397 396 398 struct timespec64; 397 399 struct __kernel_timespec;
+1
include/net/sock.h
··· 1751 1751 struct sock *sk_alloc(struct net *net, int family, gfp_t priority, 1752 1752 struct proto *prot, int kern); 1753 1753 void sk_free(struct sock *sk); 1754 + void sk_net_refcnt_upgrade(struct sock *sk); 1754 1755 void sk_destruct(struct sock *sk); 1755 1756 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority); 1756 1757 void sk_free_unlock_clone(struct sock *sk);
+2
include/trace/events/afs.h
··· 174 174 EM(afs_cell_trace_get_queue_dns, "GET q-dns ") \ 175 175 EM(afs_cell_trace_get_queue_manage, "GET q-mng ") \ 176 176 EM(afs_cell_trace_get_queue_new, "GET q-new ") \ 177 + EM(afs_cell_trace_get_server, "GET server") \ 177 178 EM(afs_cell_trace_get_vol, "GET vol ") \ 178 179 EM(afs_cell_trace_insert, "INSERT ") \ 179 180 EM(afs_cell_trace_manage, "MANAGE ") \ ··· 183 182 EM(afs_cell_trace_put_destroy, "PUT destry") \ 184 183 EM(afs_cell_trace_put_queue_work, "PUT q-work") \ 185 184 EM(afs_cell_trace_put_queue_fail, "PUT q-fail") \ 185 + EM(afs_cell_trace_put_server, "PUT server") \ 186 186 EM(afs_cell_trace_put_vol, "PUT vol ") \ 187 187 EM(afs_cell_trace_see_source, "SEE source") \ 188 188 EM(afs_cell_trace_see_ws, "SEE ws ") \
+7 -2
net/bluetooth/l2cap_core.c
··· 632 632 test_bit(FLAG_HOLD_HCI_CONN, &chan->flags)) 633 633 hci_conn_hold(conn->hcon); 634 634 635 - list_add(&chan->list, &conn->chan_l); 635 + /* Append to the list since the order matters for ECRED */ 636 + list_add_tail(&chan->list, &conn->chan_l); 636 637 } 637 638 638 639 void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan) ··· 3772 3771 struct l2cap_ecred_conn_rsp *rsp_flex = 3773 3772 container_of(&rsp->pdu.rsp, struct l2cap_ecred_conn_rsp, hdr); 3774 3773 3775 - if (test_bit(FLAG_ECRED_CONN_REQ_SENT, &chan->flags)) 3774 + /* Check if channel for outgoing connection or if it wasn't deferred 3775 + * since in those cases it must be skipped. 3776 + */ 3777 + if (test_bit(FLAG_ECRED_CONN_REQ_SENT, &chan->flags) || 3778 + !test_and_clear_bit(FLAG_DEFER_SETUP, &chan->flags)) 3776 3779 return; 3777 3780 3778 3781 /* Reset ident so only one response is sent */
+4 -10
net/core/dev.c
··· 2141 2141 struct notifier_block *nb, 2142 2142 struct netdev_net_notifier *nn) 2143 2143 { 2144 - struct net *net = dev_net(dev); 2145 2144 int err; 2146 2145 2147 - /* rtnl_net_lock() assumes dev is not yet published by 2148 - * register_netdevice(). 2149 - */ 2150 - DEBUG_NET_WARN_ON_ONCE(!list_empty(&dev->dev_list)); 2151 - 2152 - rtnl_net_lock(net); 2153 - err = __register_netdevice_notifier_net(net, nb, false); 2146 + rtnl_net_dev_lock(dev); 2147 + err = __register_netdevice_notifier_net(dev_net(dev), nb, false); 2154 2148 if (!err) { 2155 2149 nn->nb = nb; 2156 2150 list_add(&nn->list, &dev->net_notifier_list); 2157 2151 } 2158 - rtnl_net_unlock(net); 2152 + rtnl_net_dev_unlock(dev); 2159 2153 2160 2154 return err; 2161 2155 } ··· 4757 4763 * we have to raise NET_RX_SOFTIRQ. 4758 4764 */ 4759 4765 if (!sd->in_net_rx_action) 4760 - __raise_softirq_irqoff(NET_RX_SOFTIRQ); 4766 + raise_softirq_irqoff(NET_RX_SOFTIRQ); 4761 4767 } 4762 4768 4763 4769 #ifdef CONFIG_RPS
+1
net/core/gro.c
··· 653 653 skb->pkt_type = PACKET_HOST; 654 654 655 655 skb->encapsulation = 0; 656 + skb->ip_summed = CHECKSUM_NONE; 656 657 skb_shinfo(skb)->gso_type = 0; 657 658 skb_shinfo(skb)->gso_size = 0; 658 659 if (unlikely(skb->slow_gro)) {
+10
net/core/scm.c
··· 282 282 } 283 283 EXPORT_SYMBOL(put_cmsg); 284 284 285 + int put_cmsg_notrunc(struct msghdr *msg, int level, int type, int len, 286 + void *data) 287 + { 288 + /* Don't produce truncated CMSGs */ 289 + if (!msg->msg_control || msg->msg_controllen < CMSG_LEN(len)) 290 + return -ETOOSMALL; 291 + 292 + return put_cmsg(msg, level, type, len, data); 293 + } 294 + 285 295 void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss_internal) 286 296 { 287 297 struct scm_timestamping64 tss;
+1 -1
net/core/skbuff.c
··· 6033 6033 skb->offload_fwd_mark = 0; 6034 6034 skb->offload_l3_fwd_mark = 0; 6035 6035 #endif 6036 + ipvs_reset(skb); 6036 6037 6037 6038 if (!xnet) 6038 6039 return; 6039 6040 6040 - ipvs_reset(skb); 6041 6041 skb->mark = 0; 6042 6042 skb_clear_tstamp(skb); 6043 6043 }
+22 -5
net/core/sock.c
··· 2246 2246 get_net_track(net, &sk->ns_tracker, priority); 2247 2247 sock_inuse_add(net, 1); 2248 2248 } else { 2249 + net_passive_inc(net); 2249 2250 __netns_tracker_alloc(net, &sk->ns_tracker, 2250 2251 false, priority); 2251 2252 } ··· 2271 2270 static void __sk_destruct(struct rcu_head *head) 2272 2271 { 2273 2272 struct sock *sk = container_of(head, struct sock, sk_rcu); 2273 + struct net *net = sock_net(sk); 2274 2274 struct sk_filter *filter; 2275 2275 2276 2276 if (sk->sk_destruct) ··· 2303 2301 put_cred(sk->sk_peer_cred); 2304 2302 put_pid(sk->sk_peer_pid); 2305 2303 2306 - if (likely(sk->sk_net_refcnt)) 2307 - put_net_track(sock_net(sk), &sk->ns_tracker); 2308 - else 2309 - __netns_tracker_free(sock_net(sk), &sk->ns_tracker, false); 2310 - 2304 + if (likely(sk->sk_net_refcnt)) { 2305 + put_net_track(net, &sk->ns_tracker); 2306 + } else { 2307 + __netns_tracker_free(net, &sk->ns_tracker, false); 2308 + net_passive_dec(net); 2309 + } 2311 2310 sk_prot_free(sk->sk_prot_creator, sk); 2312 2311 } 2312 + 2313 + void sk_net_refcnt_upgrade(struct sock *sk) 2314 + { 2315 + struct net *net = sock_net(sk); 2316 + 2317 + WARN_ON_ONCE(sk->sk_net_refcnt); 2318 + __netns_tracker_free(net, &sk->ns_tracker, false); 2319 + net_passive_dec(net); 2320 + sk->sk_net_refcnt = 1; 2321 + get_net_track(net, &sk->ns_tracker, GFP_KERNEL); 2322 + sock_inuse_add(net, 1); 2323 + } 2324 + EXPORT_SYMBOL_GPL(sk_net_refcnt_upgrade); 2313 2325 2314 2326 void sk_destruct(struct sock *sk) 2315 2327 { ··· 2421 2405 * is not properly dismantling its kernel sockets at netns 2422 2406 * destroy time. 2423 2407 */ 2408 + net_passive_inc(sock_net(newsk)); 2424 2409 __netns_tracker_alloc(sock_net(newsk), &newsk->ns_tracker, 2425 2410 false, priority); 2426 2411 }
+2 -1
net/core/sysctl_net_core.c
··· 34 34 static int min_rcvbuf = SOCK_MIN_RCVBUF; 35 35 static int max_skb_frags = MAX_SKB_FRAGS; 36 36 static int min_mem_pcpu_rsv = SK_MEMORY_PCPU_RESERVE; 37 + static int netdev_budget_usecs_min = 2 * USEC_PER_SEC / HZ; 37 38 38 39 static int net_msg_warn; /* Unused, but still a sysctl */ 39 40 ··· 588 587 .maxlen = sizeof(unsigned int), 589 588 .mode = 0644, 590 589 .proc_handler = proc_dointvec_minmax, 591 - .extra1 = SYSCTL_ZERO, 590 + .extra1 = &netdev_budget_usecs_min, 592 591 }, 593 592 { 594 593 .procname = "fb_tunnels_only_for_init_net",
+16
net/ethtool/common.c
··· 6 6 #include <linux/rtnetlink.h> 7 7 #include <linux/ptp_clock_kernel.h> 8 8 #include <linux/phy_link_topology.h> 9 + #include <net/netdev_queues.h> 9 10 10 11 #include "netlink.h" 11 12 #include "common.h" ··· 770 769 * mean the ops attached to a netdev later on are sane. 771 770 */ 772 771 return 0; 772 + } 773 + 774 + void ethtool_ringparam_get_cfg(struct net_device *dev, 775 + struct ethtool_ringparam *param, 776 + struct kernel_ethtool_ringparam *kparam, 777 + struct netlink_ext_ack *extack) 778 + { 779 + memset(param, 0, sizeof(*param)); 780 + memset(kparam, 0, sizeof(*kparam)); 781 + 782 + param->cmd = ETHTOOL_GRINGPARAM; 783 + dev->ethtool_ops->get_ringparam(dev, param, kparam, extack); 784 + 785 + /* Driver gives us current state, we want to return current config */ 786 + kparam->tcp_data_split = dev->cfg->hds_config; 773 787 } 774 788 775 789 static void ethtool_init_tsinfo(struct kernel_ethtool_ts_info *info)
+6
net/ethtool/common.h
··· 51 51 struct ethtool_channels channels, 52 52 struct genl_info *info); 53 53 int ethtool_check_rss_ctx_busy(struct net_device *dev, u32 rss_context); 54 + 55 + void ethtool_ringparam_get_cfg(struct net_device *dev, 56 + struct ethtool_ringparam *param, 57 + struct kernel_ethtool_ringparam *kparam, 58 + struct netlink_ext_ack *extack); 59 + 54 60 int __ethtool_get_ts_info(struct net_device *dev, struct kernel_ethtool_ts_info *info); 55 61 int ethtool_get_ts_info_by_phc(struct net_device *dev, 56 62 struct kernel_ethtool_ts_info *info,
+2 -2
net/ethtool/ioctl.c
··· 2059 2059 2060 2060 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr) 2061 2061 { 2062 - struct ethtool_ringparam ringparam, max = { .cmd = ETHTOOL_GRINGPARAM }; 2063 2062 struct kernel_ethtool_ringparam kernel_ringparam; 2063 + struct ethtool_ringparam ringparam, max; 2064 2064 int ret; 2065 2065 2066 2066 if (!dev->ethtool_ops->set_ringparam || !dev->ethtool_ops->get_ringparam) ··· 2069 2069 if (copy_from_user(&ringparam, useraddr, sizeof(ringparam))) 2070 2070 return -EFAULT; 2071 2071 2072 - dev->ethtool_ops->get_ringparam(dev, &max, &kernel_ringparam, NULL); 2072 + ethtool_ringparam_get_cfg(dev, &max, &kernel_ringparam, NULL); 2073 2073 2074 2074 /* ensure new ring parameters are within the maximums */ 2075 2075 if (ringparam.rx_pending > max.rx_max_pending ||
+4 -5
net/ethtool/rings.c
··· 215 215 static int 216 216 ethnl_set_rings(struct ethnl_req_info *req_info, struct genl_info *info) 217 217 { 218 - struct kernel_ethtool_ringparam kernel_ringparam = {}; 219 - struct ethtool_ringparam ringparam = {}; 218 + struct kernel_ethtool_ringparam kernel_ringparam; 220 219 struct net_device *dev = req_info->dev; 220 + struct ethtool_ringparam ringparam; 221 221 struct nlattr **tb = info->attrs; 222 222 const struct nlattr *err_attr; 223 223 bool mod = false; 224 224 int ret; 225 225 226 - dev->ethtool_ops->get_ringparam(dev, &ringparam, 227 - &kernel_ringparam, info->extack); 228 - kernel_ringparam.tcp_data_split = dev->cfg->hds_config; 226 + ethtool_ringparam_get_cfg(dev, &ringparam, &kernel_ringparam, 227 + info->extack); 229 228 230 229 ethnl_update_u32(&ringparam.rx_pending, tb[ETHTOOL_A_RINGS_RX], &mod); 231 230 ethnl_update_u32(&ringparam.rx_mini_pending,
+10 -16
net/ipv4/tcp.c
··· 2457 2457 */ 2458 2458 memset(&dmabuf_cmsg, 0, sizeof(dmabuf_cmsg)); 2459 2459 dmabuf_cmsg.frag_size = copy; 2460 - err = put_cmsg(msg, SOL_SOCKET, SO_DEVMEM_LINEAR, 2461 - sizeof(dmabuf_cmsg), &dmabuf_cmsg); 2462 - if (err || msg->msg_flags & MSG_CTRUNC) { 2463 - msg->msg_flags &= ~MSG_CTRUNC; 2464 - if (!err) 2465 - err = -ETOOSMALL; 2460 + err = put_cmsg_notrunc(msg, SOL_SOCKET, 2461 + SO_DEVMEM_LINEAR, 2462 + sizeof(dmabuf_cmsg), 2463 + &dmabuf_cmsg); 2464 + if (err) 2466 2465 goto out; 2467 - } 2468 2466 2469 2467 sent += copy; 2470 2468 ··· 2516 2518 offset += copy; 2517 2519 remaining_len -= copy; 2518 2520 2519 - err = put_cmsg(msg, SOL_SOCKET, 2520 - SO_DEVMEM_DMABUF, 2521 - sizeof(dmabuf_cmsg), 2522 - &dmabuf_cmsg); 2523 - if (err || msg->msg_flags & MSG_CTRUNC) { 2524 - msg->msg_flags &= ~MSG_CTRUNC; 2525 - if (!err) 2526 - err = -ETOOSMALL; 2521 + err = put_cmsg_notrunc(msg, SOL_SOCKET, 2522 + SO_DEVMEM_DMABUF, 2523 + sizeof(dmabuf_cmsg), 2524 + &dmabuf_cmsg); 2525 + if (err) 2527 2526 goto out; 2528 - } 2529 2527 2530 2528 atomic_long_inc(&niov->pp_ref_count); 2531 2529 tcp_xa_pool.netmems[tcp_xa_pool.idx++] = skb_frag_netmem(frag);
+4 -6
net/ipv4/tcp_minisocks.c
··· 815 815 816 816 /* In sequence, PAWS is OK. */ 817 817 818 - /* TODO: We probably should defer ts_recent change once 819 - * we take ownership of @req. 820 - */ 821 - if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) 822 - WRITE_ONCE(req->ts_recent, tmp_opt.rcv_tsval); 823 - 824 818 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) { 825 819 /* Truncate SYN, it is out of window starting 826 820 at tcp_rsk(req)->rcv_isn + 1. */ ··· 862 868 req, &own_req); 863 869 if (!child) 864 870 goto listen_overflow; 871 + 872 + if (own_req && tmp_opt.saw_tstamp && 873 + !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) 874 + tcp_sk(child)->rx_opt.ts_recent = tmp_opt.rcv_tsval; 865 875 866 876 if (own_req && rsk_drop_req(req)) { 867 877 reqsk_queue_removed(&inet_csk(req->rsk_listener)->icsk_accept_queue, req);
+12 -2
net/ipv6/rpl_iptunnel.c
··· 262 262 { 263 263 struct dst_entry *orig_dst = skb_dst(skb); 264 264 struct dst_entry *dst = NULL; 265 + struct lwtunnel_state *lwtst; 265 266 struct rpl_lwt *rlwt; 266 267 int err; 267 268 268 - rlwt = rpl_lwt_lwtunnel(orig_dst->lwtstate); 269 + /* We cannot dereference "orig_dst" once ip6_route_input() or 270 + * skb_dst_drop() is called. However, in order to detect a dst loop, we 271 + * need the address of its lwtstate. So, save the address of lwtstate 272 + * now and use it later as a comparison. 273 + */ 274 + lwtst = orig_dst->lwtstate; 275 + 276 + rlwt = rpl_lwt_lwtunnel(lwtst); 269 277 270 278 local_bh_disable(); 271 279 dst = dst_cache_get(&rlwt->cache); ··· 288 280 if (!dst) { 289 281 ip6_route_input(skb); 290 282 dst = skb_dst(skb); 291 - if (!dst->error) { 283 + 284 + /* cache only if we don't create a dst reference loop */ 285 + if (!dst->error && lwtst != dst->lwtstate) { 292 286 local_bh_disable(); 293 287 dst_cache_set_ip6(&rlwt->cache, dst, 294 288 &ipv6_hdr(skb)->saddr);
+12 -2
net/ipv6/seg6_iptunnel.c
··· 472 472 { 473 473 struct dst_entry *orig_dst = skb_dst(skb); 474 474 struct dst_entry *dst = NULL; 475 + struct lwtunnel_state *lwtst; 475 476 struct seg6_lwt *slwt; 476 477 int err; 477 478 478 - slwt = seg6_lwt_lwtunnel(orig_dst->lwtstate); 479 + /* We cannot dereference "orig_dst" once ip6_route_input() or 480 + * skb_dst_drop() is called. However, in order to detect a dst loop, we 481 + * need the address of its lwtstate. So, save the address of lwtstate 482 + * now and use it later as a comparison. 483 + */ 484 + lwtst = orig_dst->lwtstate; 485 + 486 + slwt = seg6_lwt_lwtunnel(lwtst); 479 487 480 488 local_bh_disable(); 481 489 dst = dst_cache_get(&slwt->cache); ··· 498 490 if (!dst) { 499 491 ip6_route_input(skb); 500 492 dst = skb_dst(skb); 501 - if (!dst->error) { 493 + 494 + /* cache only if we don't create a dst reference loop */ 495 + if (!dst->error && lwtst != dst->lwtstate) { 502 496 local_bh_disable(); 503 497 dst_cache_set_ip6(&slwt->cache, dst, 504 498 &ipv6_hdr(skb)->saddr);
-5
net/mptcp/pm_netlink.c
··· 1514 1514 if (mptcp_pm_is_userspace(msk)) 1515 1515 goto next; 1516 1516 1517 - if (list_empty(&msk->conn_list)) { 1518 - mptcp_pm_remove_anno_addr(msk, addr, false); 1519 - goto next; 1520 - } 1521 - 1522 1517 lock_sock(sk); 1523 1518 remove_subflow = mptcp_lookup_subflow_by_saddr(&msk->conn_list, addr); 1524 1519 mptcp_pm_remove_anno_addr(msk, addr, remove_subflow &&
+2
net/mptcp/protocol.h
··· 1199 1199 pr_debug("TCP fallback already done (msk=%p)\n", msk); 1200 1200 return; 1201 1201 } 1202 + if (WARN_ON_ONCE(!READ_ONCE(msk->allow_infinite_fallback))) 1203 + return; 1202 1204 set_bit(MPTCP_FALLBACK_DONE, &msk->flags); 1203 1205 } 1204 1206
+2 -18
net/mptcp/subflow.c
··· 1142 1142 if (data_len == 0) { 1143 1143 pr_debug("infinite mapping received\n"); 1144 1144 MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPRX); 1145 - subflow->map_data_len = 0; 1146 1145 return MAPPING_INVALID; 1147 1146 } 1148 1147 ··· 1285 1286 mptcp_schedule_work(sk); 1286 1287 } 1287 1288 1288 - static bool subflow_can_fallback(struct mptcp_subflow_context *subflow) 1289 - { 1290 - struct mptcp_sock *msk = mptcp_sk(subflow->conn); 1291 - 1292 - if (subflow->mp_join) 1293 - return false; 1294 - else if (READ_ONCE(msk->csum_enabled)) 1295 - return !subflow->valid_csum_seen; 1296 - else 1297 - return READ_ONCE(msk->allow_infinite_fallback); 1298 - } 1299 - 1300 1289 static void mptcp_subflow_fail(struct mptcp_sock *msk, struct sock *ssk) 1301 1290 { 1302 1291 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk); ··· 1380 1393 return true; 1381 1394 } 1382 1395 1383 - if (!subflow_can_fallback(subflow) && subflow->map_data_len) { 1396 + if (!READ_ONCE(msk->allow_infinite_fallback)) { 1384 1397 /* fatal protocol error, close the socket. 1385 1398 * subflow_error_report() will introduce the appropriate barriers 1386 1399 */ ··· 1759 1772 * needs it. 1760 1773 * Update ns_tracker to current stack trace and refcounted tracker. 1761 1774 */ 1762 - __netns_tracker_free(net, &sf->sk->ns_tracker, false); 1763 - sf->sk->sk_net_refcnt = 1; 1764 - get_net_track(net, &sf->sk->ns_tracker, GFP_KERNEL); 1765 - sock_inuse_add(net, 1); 1775 + sk_net_refcnt_upgrade(sf->sk); 1766 1776 err = tcp_set_ulp(sf->sk, "mptcp"); 1767 1777 if (err) 1768 1778 goto err_free;
-10
net/netlink/af_netlink.c
··· 795 795 796 796 sock_prot_inuse_add(sock_net(sk), &netlink_proto, -1); 797 797 798 - /* Because struct net might disappear soon, do not keep a pointer. */ 799 - if (!sk->sk_net_refcnt && sock_net(sk) != &init_net) { 800 - __netns_tracker_free(sock_net(sk), &sk->ns_tracker, false); 801 - /* Because of deferred_put_nlk_sk and use of work queue, 802 - * it is possible netns will be freed before this socket. 803 - */ 804 - sock_net_set(sk, &init_net); 805 - __netns_tracker_alloc(&init_net, &sk->ns_tracker, 806 - false, GFP_KERNEL); 807 - } 808 798 call_rcu(&nlk->rcu, deferred_put_nlk_sk); 809 799 return 0; 810 800 }
+2 -6
net/rds/tcp.c
··· 504 504 release_sock(sk); 505 505 return false; 506 506 } 507 - /* Update ns_tracker to current stack trace and refcounted tracker */ 508 - __netns_tracker_free(net, &sk->ns_tracker, false); 509 - 510 - sk->sk_net_refcnt = 1; 511 - netns_tracker_alloc(net, &sk->ns_tracker, GFP_KERNEL); 512 - sock_inuse_add(net, 1); 507 + sk_net_refcnt_upgrade(sk); 508 + put_net(net); 513 509 } 514 510 rtn = net_generic(net, rds_tcp_netid); 515 511 if (rtn->sndbuf_size > 0) {
-1
net/rxrpc/ar-internal.h
··· 360 360 u8 pmtud_jumbo; /* Max jumbo packets for the MTU */ 361 361 bool ackr_adv_pmtud; /* T if the peer advertises path-MTU */ 362 362 unsigned int ackr_max_data; /* Maximum data advertised by peer */ 363 - seqcount_t mtu_lock; /* Lockless MTU access management */ 364 363 unsigned int if_mtu; /* Local interface MTU (- hdrsize) for this peer */ 365 364 unsigned int max_data; /* Maximum packet data capacity for this peer */ 366 365 unsigned short hdrsize; /* header size (IP + UDP + RxRPC) */
-2
net/rxrpc/input.c
··· 810 810 if (max_mtu < peer->max_data) { 811 811 trace_rxrpc_pmtud_reduce(peer, sp->hdr.serial, max_mtu, 812 812 rxrpc_pmtud_reduce_ack); 813 - write_seqcount_begin(&peer->mtu_lock); 814 813 peer->max_data = max_mtu; 815 - write_seqcount_end(&peer->mtu_lock); 816 814 } 817 815 818 816 max_data = umin(max_mtu, peer->max_data);
+1 -8
net/rxrpc/peer_event.c
··· 130 130 peer->pmtud_bad = max_data + 1; 131 131 132 132 trace_rxrpc_pmtud_reduce(peer, 0, max_data, rxrpc_pmtud_reduce_icmp); 133 - write_seqcount_begin(&peer->mtu_lock); 134 133 peer->max_data = max_data; 135 - write_seqcount_end(&peer->mtu_lock); 136 134 } 137 135 } 138 136 ··· 406 408 } 407 409 408 410 max_data = umin(max_data, peer->ackr_max_data); 409 - if (max_data != peer->max_data) { 410 - preempt_disable(); 411 - write_seqcount_begin(&peer->mtu_lock); 411 + if (max_data != peer->max_data) 412 412 peer->max_data = max_data; 413 - write_seqcount_end(&peer->mtu_lock); 414 - preempt_enable(); 415 - } 416 413 417 414 jumbo = max_data + sizeof(struct rxrpc_jumbo_header); 418 415 jumbo /= RXRPC_JUMBO_SUBPKTLEN;
+2 -3
net/rxrpc/peer_object.c
··· 235 235 peer->service_conns = RB_ROOT; 236 236 seqlock_init(&peer->service_conn_lock); 237 237 spin_lock_init(&peer->lock); 238 - seqcount_init(&peer->mtu_lock); 239 238 peer->debug_id = atomic_inc_return(&rxrpc_debug_id); 240 239 peer->recent_srtt_us = UINT_MAX; 241 240 peer->cong_ssthresh = RXRPC_TX_MAX_WINDOW; ··· 324 325 hash_key = rxrpc_peer_hash_key(local, &peer->srx); 325 326 rxrpc_init_peer(local, peer, hash_key); 326 327 327 - spin_lock_bh(&rxnet->peer_hash_lock); 328 + spin_lock(&rxnet->peer_hash_lock); 328 329 hash_add_rcu(rxnet->peer_hash, &peer->hash_link, hash_key); 329 330 list_add_tail(&peer->keepalive_link, &rxnet->peer_keepalive_new); 330 - spin_unlock_bh(&rxnet->peer_hash_lock); 331 + spin_unlock(&rxnet->peer_hash_lock); 331 332 } 332 333 333 334 /*
+12
net/rxrpc/rxperf.c
··· 478 478 call->unmarshal++; 479 479 fallthrough; 480 480 case 2: 481 + ret = rxperf_extract_data(call, true); 482 + if (ret < 0) 483 + return ret; 484 + 485 + /* Deal with the terminal magic cookie. */ 486 + call->iov_len = 4; 487 + call->kvec[0].iov_len = call->iov_len; 488 + call->kvec[0].iov_base = call->tmp; 489 + iov_iter_kvec(&call->iter, READ, call->kvec, 1, call->iov_len); 490 + call->unmarshal++; 491 + fallthrough; 492 + case 3: 481 493 ret = rxperf_extract_data(call, false); 482 494 if (ret < 0) 483 495 return ret;
+1 -4
net/smc/af_smc.c
··· 3337 3337 * which need net ref. 3338 3338 */ 3339 3339 sk = smc->clcsock->sk; 3340 - __netns_tracker_free(net, &sk->ns_tracker, false); 3341 - sk->sk_net_refcnt = 1; 3342 - get_net_track(net, &sk->ns_tracker, GFP_KERNEL); 3343 - sock_inuse_add(net, 1); 3340 + sk_net_refcnt_upgrade(sk); 3344 3341 return 0; 3345 3342 } 3346 3343
+1 -4
net/sunrpc/svcsock.c
··· 1541 1541 newlen = error; 1542 1542 1543 1543 if (protocol == IPPROTO_TCP) { 1544 - __netns_tracker_free(net, &sock->sk->ns_tracker, false); 1545 - sock->sk->sk_net_refcnt = 1; 1546 - get_net_track(net, &sock->sk->ns_tracker, GFP_KERNEL); 1547 - sock_inuse_add(net, 1); 1544 + sk_net_refcnt_upgrade(sock->sk); 1548 1545 if ((error = kernel_listen(sock, 64)) < 0) 1549 1546 goto bummer; 1550 1547 }
+2 -6
net/sunrpc/xprtsock.c
··· 1941 1941 goto out; 1942 1942 } 1943 1943 1944 - if (protocol == IPPROTO_TCP) { 1945 - __netns_tracker_free(xprt->xprt_net, &sock->sk->ns_tracker, false); 1946 - sock->sk->sk_net_refcnt = 1; 1947 - get_net_track(xprt->xprt_net, &sock->sk->ns_tracker, GFP_KERNEL); 1948 - sock_inuse_add(xprt->xprt_net, 1); 1949 - } 1944 + if (protocol == IPPROTO_TCP) 1945 + sk_net_refcnt_upgrade(sock->sk); 1950 1946 1951 1947 filp = sock_alloc_file(sock, O_NONBLOCK, NULL); 1952 1948 if (IS_ERR(filp))
+1
net/unix/af_unix.c
··· 2102 2102 goto out_sock_put; 2103 2103 } 2104 2104 2105 + sock_put(other); 2105 2106 goto lookup; 2106 2107 } 2107 2108
+142 -3
tools/testing/selftests/drivers/net/hds.py
··· 2 2 # SPDX-License-Identifier: GPL-2.0 3 3 4 4 import errno 5 + import os 5 6 from lib.py import ksft_run, ksft_exit, ksft_eq, ksft_raises, KsftSkipEx 6 - from lib.py import EthtoolFamily, NlError 7 + from lib.py import CmdExitFailure, EthtoolFamily, NlError 7 8 from lib.py import NetDrvEnv 9 + from lib.py import defer, ethtool, ip 8 10 9 - def get_hds(cfg, netnl) -> None: 11 + 12 + def _get_hds_mode(cfg, netnl) -> str: 10 13 try: 11 14 rings = netnl.rings_get({'header': {'dev-index': cfg.ifindex}}) 12 15 except NlError as e: 13 16 raise KsftSkipEx('ring-get not supported by device') 14 17 if 'tcp-data-split' not in rings: 15 18 raise KsftSkipEx('tcp-data-split not supported by device') 19 + return rings['tcp-data-split'] 20 + 21 + 22 + def _xdp_onoff(cfg): 23 + test_dir = os.path.dirname(os.path.realpath(__file__)) 24 + prog = test_dir + "/../../net/lib/xdp_dummy.bpf.o" 25 + ip("link set dev %s xdp obj %s sec xdp" % 26 + (cfg.ifname, prog)) 27 + ip("link set dev %s xdp off" % cfg.ifname) 28 + 29 + 30 + def _ioctl_ringparam_modify(cfg, netnl) -> None: 31 + """ 32 + Helper for performing a hopefully unimportant IOCTL SET. 33 + IOCTL does not support HDS, so it should not affect the HDS config. 34 + """ 35 + try: 36 + rings = netnl.rings_get({'header': {'dev-index': cfg.ifindex}}) 37 + except NlError as e: 38 + raise KsftSkipEx('ring-get not supported by device') 39 + 40 + if 'tx' not in rings: 41 + raise KsftSkipEx('setting Tx ring size not supported') 42 + 43 + try: 44 + ethtool(f"--disable-netlink -G {cfg.ifname} tx {rings['tx'] // 2}") 45 + except CmdExitFailure as e: 46 + ethtool(f"--disable-netlink -G {cfg.ifname} tx {rings['tx'] * 2}") 47 + defer(ethtool, f"-G {cfg.ifname} tx {rings['tx']}") 48 + 49 + 50 + def get_hds(cfg, netnl) -> None: 51 + _get_hds_mode(cfg, netnl) 52 + 16 53 17 54 def get_hds_thresh(cfg, netnl) -> None: 18 55 try: ··· 141 104 netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 'hds-thresh': hds_gt}) 142 105 ksft_eq(e.exception.nl_msg.error, -errno.EINVAL) 143 106 107 + 108 + def set_xdp(cfg, netnl) -> None: 109 + """ 110 + Enable single-buffer XDP on the device. 111 + When HDS is in "auto" / UNKNOWN mode, XDP installation should work. 112 + """ 113 + mode = _get_hds_mode(cfg, netnl) 114 + if mode == 'enabled': 115 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 116 + 'tcp-data-split': 'unknown'}) 117 + 118 + _xdp_onoff(cfg) 119 + 120 + 121 + def enabled_set_xdp(cfg, netnl) -> None: 122 + """ 123 + Enable single-buffer XDP on the device. 124 + When HDS is in "enabled" mode, XDP installation should not work. 125 + """ 126 + _get_hds_mode(cfg, netnl) 127 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 128 + 'tcp-data-split': 'enabled'}) 129 + 130 + defer(netnl.rings_set, {'header': {'dev-index': cfg.ifindex}, 131 + 'tcp-data-split': 'unknown'}) 132 + 133 + with ksft_raises(CmdExitFailure) as e: 134 + _xdp_onoff(cfg) 135 + 136 + 137 + def set_xdp(cfg, netnl) -> None: 138 + """ 139 + Enable single-buffer XDP on the device. 140 + When HDS is in "auto" / UNKNOWN mode, XDP installation should work. 141 + """ 142 + mode = _get_hds_mode(cfg, netnl) 143 + if mode == 'enabled': 144 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 145 + 'tcp-data-split': 'unknown'}) 146 + 147 + _xdp_onoff(cfg) 148 + 149 + 150 + def enabled_set_xdp(cfg, netnl) -> None: 151 + """ 152 + Enable single-buffer XDP on the device. 153 + When HDS is in "enabled" mode, XDP installation should not work. 154 + """ 155 + _get_hds_mode(cfg, netnl) # Trigger skip if not supported 156 + 157 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 158 + 'tcp-data-split': 'enabled'}) 159 + defer(netnl.rings_set, {'header': {'dev-index': cfg.ifindex}, 160 + 'tcp-data-split': 'unknown'}) 161 + 162 + with ksft_raises(CmdExitFailure) as e: 163 + _xdp_onoff(cfg) 164 + 165 + 166 + def ioctl(cfg, netnl) -> None: 167 + mode1 = _get_hds_mode(cfg, netnl) 168 + _ioctl_ringparam_modify(cfg, netnl) 169 + mode2 = _get_hds_mode(cfg, netnl) 170 + 171 + ksft_eq(mode1, mode2) 172 + 173 + 174 + def ioctl_set_xdp(cfg, netnl) -> None: 175 + """ 176 + Like set_xdp(), but we perturb the settings via the legacy ioctl. 177 + """ 178 + mode = _get_hds_mode(cfg, netnl) 179 + if mode == 'enabled': 180 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 181 + 'tcp-data-split': 'unknown'}) 182 + 183 + _ioctl_ringparam_modify(cfg, netnl) 184 + 185 + _xdp_onoff(cfg) 186 + 187 + 188 + def ioctl_enabled_set_xdp(cfg, netnl) -> None: 189 + """ 190 + Enable single-buffer XDP on the device. 191 + When HDS is in "enabled" mode, XDP installation should not work. 192 + """ 193 + _get_hds_mode(cfg, netnl) # Trigger skip if not supported 194 + 195 + netnl.rings_set({'header': {'dev-index': cfg.ifindex}, 196 + 'tcp-data-split': 'enabled'}) 197 + defer(netnl.rings_set, {'header': {'dev-index': cfg.ifindex}, 198 + 'tcp-data-split': 'unknown'}) 199 + 200 + with ksft_raises(CmdExitFailure) as e: 201 + _xdp_onoff(cfg) 202 + 203 + 144 204 def main() -> None: 145 205 with NetDrvEnv(__file__, queue_count=3) as cfg: 146 206 ksft_run([get_hds, ··· 246 112 set_hds_enable, 247 113 set_hds_thresh_zero, 248 114 set_hds_thresh_max, 249 - set_hds_thresh_gt], 115 + set_hds_thresh_gt, 116 + set_xdp, 117 + enabled_set_xdp, 118 + ioctl, 119 + ioctl_set_xdp, 120 + ioctl_enabled_set_xdp], 250 121 args=(cfg, EthtoolFamily())) 251 122 ksft_exit() 252 123
+3 -4
tools/testing/selftests/drivers/net/queues.py
··· 45 45 46 46 netnl = EthtoolFamily() 47 47 channels = netnl.channels_get({'header': {'dev-index': cfg.ifindex}}) 48 - if channels['combined-count'] == 0: 49 - rx_type = 'rx' 50 - else: 51 - rx_type = 'combined' 48 + rx_type = 'rx' 49 + if channels.get('combined-count', 0) > 0: 50 + rx_type = 'combined' 52 51 53 52 expected = curr_queues - 1 54 53 cmd(f"ethtool -L {cfg.dev['ifname']} {rx_type} {expected}", timeout=10)
+3
tools/testing/selftests/net/lib/Makefile
··· 9 9 TEST_FILES += ../../../../net/ynl 10 10 11 11 TEST_GEN_FILES += csum 12 + TEST_GEN_FILES += $(patsubst %.c,%.o,$(wildcard *.bpf.c)) 12 13 13 14 TEST_INCLUDES := $(wildcard py/*.py sh/*.sh) 14 15 15 16 include ../../lib.mk 17 + 18 + include ../bpf.mk
+13
tools/testing/selftests/net/lib/xdp_dummy.bpf.c
··· 1 + // SPDX-License-Identifier: GPL-2.0 2 + 3 + #define KBUILD_MODNAME "xdp_dummy" 4 + #include <linux/bpf.h> 5 + #include <bpf/bpf_helpers.h> 6 + 7 + SEC("xdp") 8 + int xdp_dummy_prog(struct xdp_md *ctx) 9 + { 10 + return XDP_PASS; 11 + } 12 + 13 + char _license[] SEC("license") = "GPL";