tcp: BIG TCP implementation
Subsystems (17)
v7 cover tcp: BIG TCP implementation
From: Eric Dumazet <[email protected]>
This series implements BIG TCP as presented in netdev 0x15:
https://netdevconf.info/0x15/session.html?BIG-TCP
Jonathan Corbet made a nice summary: https://lwn.net/Articles/884104/
Standard TSO/GRO packet limit is 64KB
With BIG TCP, we allow bigger TSO/GRO packet sizes for IPv6 traffic.
Note that this feature is by default not enabled, because it might break some eBPF programs assuming TCP header immediately follows IPv6 header.
While tcpdump recognizes the HBH/Jumbo header, standard pcap filters are unable to skip over IPv6 extension headers.
Reducing number of packets traversing networking stack usually improves performance, as shown on this experiment using a 100Gbit NIC, and 4K MTU.
'Standard' performance with current (74KB) limits.
for i in {1..10}; do ./netperf -t TCP_RR -H iroa23 -- -r80000,80000 -O MIN_LATENCY,P90_LATENCY,P99_LATENCY,THROUGHPUT|tail -1; done
77 138 183 8542.19 79 143 178 8215.28 70 117 164 9543.39 80 144 176 8183.71 78 126 155 9108.47 80 146 184 8115.19 71 113 165 9510.96 74 113 164 9518.74 79 137 178 8575.04 73 111 171 9561.73
Now enable BIG TCP on both hosts.
ip link set dev eth0 gro_max_size 185000 gso_max_size 185000
for i in {1..10}; do ./netperf -t TCP_RR -H iroa23 -- -r80000,80000 -O MIN_LATENCY,P90_LATENCY,P99_LATENCY,THROUGHPUT|tail -1; done
57 83 117 13871.38 64 118 155 11432.94 65 116 148 11507.62 60 105 136 12645.15 60 103 135 12760.34 60 102 134 12832.64 62 109 132 10877.68 58 82 115 14052.93 57 83 124 14212.58 57 82 119 14196.01
We see an increase of transactions per second, and lower latencies as well.
v7: adopt unsafe_memcpy() in mlx5 to avoid FORTIFY warnings.
v6: fix a compilation error for CONFIG_IPV6=n in
"net: allow gso_max_size to exceed 65536", reported by kernel bots.
v5: Replaced two patches (that were adding new attributes) with patches
from Alexander Duyck. Idea is to reuse existing gso_max_size/gro_max_size
v4: Rebased on top of Jakub series (Merge branch 'tso-gso-limit-split')
max_tso_size is now family independent.
v3: Fixed a typo in RFC number (Alexander)
Added Reviewed-by: tags from Tariq on mlx4/mlx5 parts.
v2: Removed the MAX_SKB_FRAGS change, this belongs to a different series.
Addressed feedback, for Alexander and nvidia folks.
Alexander Duyck (2):
net: allow gso_max_size to exceed 65536
net: allow gro_max_size to exceed 65536
Coco Li (1):
ipv6: Add hop-by-hop header to jumbograms in ip6_output
Eric Dumazet (10):
net: add IFLA_TSO_{MAX_SIZE|SEGS} attributes
net: limit GSO_MAX_SIZE to 524280 bytes
tcp_cubic: make hystart_ack_delay() aware of BIG TCP
ipv6: add struct hop_jumbo_hdr definition ipv6/gso: remove temporary HBH/jumbo header ipv6/gro: insert temporary HBH/jumbo header
net: loopback: enable BIG TCP packets
veth: enable BIG TCP packets
mlx4: support BIG TCP packets
mlx5: support BIG TCP packets
drivers/net/ethernet/amd/xgbe/xgbe.h | 3 +- .../net/ethernet/mellanox/mlx4/en_netdev.c | 3 + drivers/net/ethernet/mellanox/mlx4/en_tx.c | 47 ++++++-- .../net/ethernet/mellanox/mlx5/core/en_main.c | 1 + .../net/ethernet/mellanox/mlx5/core/en_rx.c | 2 +- .../net/ethernet/mellanox/mlx5/core/en_tx.c | 111 ++++++++++++++---- drivers/net/ethernet/sfc/ef100_nic.c | 3 +- drivers/net/ethernet/sfc/falcon/tx.c | 3 +- drivers/net/ethernet/sfc/tx_common.c | 3 +- drivers/net/ethernet/synopsys/dwc-xlgmac.h | 3 +- drivers/net/hyperv/rndis_filter.c | 2 +- drivers/net/loopback.c | 2 + drivers/net/veth.c | 1 + drivers/scsi/fcoe/fcoe.c | 2 +- include/linux/ipv6.h | 1 + include/linux/netdevice.h | 15 ++- include/net/ipv6.h | 44 +++++++ include/uapi/linux/if_link.h | 2 + net/bpf/test_run.c | 2 +- net/core/dev.c | 9 +- net/core/gro.c | 8 ++ net/core/rtnetlink.c | 16 ++- net/core/sock.c | 14 +++ net/ipv4/tcp_bbr.c | 2 +- net/ipv4/tcp_cubic.c | 4 +- net/ipv4/tcp_output.c | 2 +- net/ipv6/ip6_offload.c | 56 ++++++++- net/ipv6/ip6_output.c | 22 +++- net/sctp/output.c | 3 +- tools/include/uapi/linux/if_link.h | 2 + 30 files changed, 321 insertions(+), 67 deletions(-)
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 1/13 net: add IFLA_TSO_{MAX_SIZE|SEGS} attributes
From: Eric Dumazet <[email protected]>
New netlink attributes IFLA_TSO_MAX_SIZE and IFLA_TSO_MAX_SEGS are used to report to user-space the device TSO limits.
ip -d link sh dev eth1
...
tso_max_size 65536 tso_max_segs 65535
--- include/uapi/linux/if_link.h | 2 ++ net/core/rtnetlink.c | 6 ++++++ tools/include/uapi/linux/if_link.h | 2 ++ 3 files changed, 10 insertions(+)
include/uapi/linux/if_link.h +2 -0
@@ -368,6 +368,8 @@ enum {IFLA_PARENT_DEV_NAME ,IFLA_PARENT_DEV_BUS_NAME ,IFLA_GRO_MAX_SIZE , +IFLA_TSO_MAX_SIZE , +IFLA_TSO_MAX_SEGS , __IFLA_MAX };
net/core/rtnetlink.c +6 -0
@@ -1064,6 +1064,8 @@ static noinline size_t if_nlmsg_size(const struct net_device *dev, +nla_total_size (4 )/* IFLA_GSO_MAX_SEGS */ +nla_total_size (4 )/* IFLA_GSO_MAX_SIZE */ +nla_total_size (4 )/* IFLA_GRO_MAX_SIZE */ + +nla_total_size (4 )/* IFLA_TSO_MAX_SIZE */ + +nla_total_size (4 )/* IFLA_TSO_MAX_SEGS */ +nla_total_size (1 )/* IFLA_OPERSTATE */ +nla_total_size (1 )/* IFLA_LINKMODE */ +nla_total_size (4 )/* IFLA_CARRIER_CHANGES */
@@ -1769,6 +1771,8 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb,nla_put_u32 (skb,IFLA_GSO_MAX_SEGS , dev->gso_max_segs) ||nla_put_u32 (skb,IFLA_GSO_MAX_SIZE , dev->gso_max_size) ||nla_put_u32 (skb,IFLA_GRO_MAX_SIZE , dev->gro_max_size) || +nla_put_u32 (skb,IFLA_TSO_MAX_SIZE , dev->tso_max_size) || +nla_put_u32 (skb,IFLA_TSO_MAX_SEGS , dev->tso_max_segs) || #ifdef CONFIG_RPS nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) || #endif
@@ -1922,6 +1926,8 @@ static const struct nla_policy ifla_policy[IFLA_MAX+1] = { [IFLA_NEW_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1), [IFLA_PARENT_DEV_NAME] = { .type = NLA_NUL_STRING }, [IFLA_GRO_MAX_SIZE] = { .type = NLA_U32 }, + [IFLA_TSO_MAX_SIZE] = { .type = NLA_REJECT }, + [IFLA_TSO_MAX_SEGS] = { .type = NLA_REJECT }, };static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX +1 ] = {
tools/include/uapi/linux/if_link.h +2 -0
@@ -348,6 +348,8 @@ enum {IFLA_PARENT_DEV_NAME ,IFLA_PARENT_DEV_BUS_NAME ,IFLA_GRO_MAX_SIZE , +IFLA_TSO_MAX_SIZE , +IFLA_TSO_MAX_SEGS , __IFLA_MAX };
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 2/13 net: allow gso_max_size to exceed 65536
In reply to Eric DumazetFrom: Alexander Duyck <[email protected]>
The code for gso_max_size was added originally to allow for debugging and workaround of buggy devices that couldn't support TSO with blocks 64K in size. The original reason for limiting it to 64K was because that was the existing limits of IPv4 and non-jumbogram IPv6 length fields.
With the addition of Big TCP we can remove this limit and allow the value to potentially go up to UINT_MAX and instead be limited by the tso_max_size value.
So in order to support this we need to go through and clean up the remaining users of the gso_max_size value so that the values will cap at 64K for non-TCPv6 flows. In addition we can clean up the GSO_MAX_SIZE value so that 64K becomes GSO_LEGACY_MAX_SIZE and UINT_MAX will now be the upper limit for GSO_MAX_SIZE.
v6: (edumazet) fixed a compile error if CONFIG_IPV6=n,
in a new sk_trim_gso_size() helper. netif_set_tso_max_size() caps the requested TSO size with GSO_MAX_SIZE.
--- drivers/net/ethernet/amd/xgbe/xgbe.h | 3 ++- drivers/net/ethernet/mellanox/mlx5/core/en_rx.c | 2 +- drivers/net/ethernet/sfc/ef100_nic.c | 3 ++- drivers/net/ethernet/sfc/falcon/tx.c | 3 ++- drivers/net/ethernet/sfc/tx_common.c | 3 ++- drivers/net/ethernet/synopsys/dwc-xlgmac.h | 3 ++- drivers/net/hyperv/rndis_filter.c | 2 +- drivers/scsi/fcoe/fcoe.c | 2 +- include/linux/netdevice.h | 4 +++- net/bpf/test_run.c | 2 +- net/core/dev.c | 7 ++++--- net/core/rtnetlink.c | 2 +- net/core/sock.c | 14 ++++++++++++++ net/ipv4/tcp_bbr.c | 2 +- net/ipv4/tcp_output.c | 2 +- net/sctp/output.c | 3 ++- 16 files changed, 40 insertions(+), 17 deletions(-)
drivers/net/ethernet/amd/xgbe/xgbe.h +2 -1
@@ -151,7 +151,8 @@#define XGBE_TX_MAX_BUF_SIZE (0x3fff & ~(64 - 1))/* Descriptors required for maximum contiguous TSO/GSO packet */ -#define XGBE_TX_MAX_SPLIT ((GSO_MAX_SIZE / XGBE_TX_MAX_BUF_SIZE) + 1) +#define XGBE_TX_MAX_SPLIT \ + ((GSO_LEGACY_MAX_SIZE / XGBE_TX_MAX_BUF_SIZE) + 1)/* Maximum possible descriptors needed for an SKB: * - Maximum number of SKB frags
drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +1 -1
@@ -2038,7 +2038,7 @@ mlx5e_hw_gro_skb_has_enough_space(struct sk_buff *skb, u16 data_bcnt) {int nr_frags =skb_shinfo (skb)->nr_frags; -return PAGE_SIZE * nr_frags + data_bcnt <=GSO_MAX_SIZE ; +return PAGE_SIZE * nr_frags + data_bcnt <=GRO_MAX_SIZE ; } static void
drivers/net/ethernet/sfc/ef100_nic.c +2 -1
@@ -1008,7 +1008,8 @@ static int ef100_process_design_param(struct efx_nic *efx, }return 0 ;case ESE_EF100_DP_GZ_TSO_MAX_PAYLOAD_LEN : - nic_data->tso_max_payload_len =min_t (u64, reader->value,GSO_MAX_SIZE ); + nic_data->tso_max_payload_len =min_t (u64, reader->value, +GSO_LEGACY_MAX_SIZE );netif_set_tso_max_size (efx->net_dev, nic_data->tso_max_payload_len);return 0 ;
drivers/net/ethernet/sfc/falcon/tx.c +2 -1
@@ -98,7 +98,8 @@ unsigned int ef4_tx_max_skb_descs(struct ef4_nic *efx)/* Possibly more for PCIe page boundaries within input fragments */ if (PAGE_SIZE >EF4_PAGE_SIZE ) max_descs += max_t(unsigned int, MAX_SKB_FRAGS, -DIV_ROUND_UP (GSO_MAX_SIZE ,EF4_PAGE_SIZE )); +DIV_ROUND_UP (GSO_LEGACY_MAX_SIZE , +EF4_PAGE_SIZE ));return max_descs; }
drivers/net/ethernet/sfc/tx_common.c +2 -1
@@ -416,7 +416,8 @@ unsigned int efx_tx_max_skb_descs(struct efx_nic *efx)/* Possibly more for PCIe page boundaries within input fragments */ if (PAGE_SIZE >EFX_PAGE_SIZE ) max_descs += max_t(unsigned int, MAX_SKB_FRAGS, -DIV_ROUND_UP (GSO_MAX_SIZE ,EFX_PAGE_SIZE )); +DIV_ROUND_UP (GSO_LEGACY_MAX_SIZE , +EFX_PAGE_SIZE ));return max_descs; }
drivers/net/ethernet/synopsys/dwc-xlgmac.h +2 -1
@@ -38,7 +38,8 @@#define XLGMAC_RX_DESC_MAX_DIRTY (XLGMAC_RX_DESC_CNT >> 3)/* Descriptors required for maximum contiguous TSO/GSO packet */ -#define XLGMAC_TX_MAX_SPLIT ((GSO_MAX_SIZE / XLGMAC_TX_MAX_BUF_SIZE) + 1) +#define XLGMAC_TX_MAX_SPLIT \ + ((GSO_LEGACY_MAX_SIZE / XLGMAC_TX_MAX_BUF_SIZE) + 1)/* Maximum possible descriptors needed for a SKB */ #define XLGMAC_TX_MAX_DESC_NR (MAX_SKB_FRAGS + XLGMAC_TX_MAX_SPLIT + 2)
drivers/net/hyperv/rndis_filter.c +1 -1
@@ -1349,7 +1349,7 @@ static int rndis_netdev_set_hwcaps(struct rndis_device *rndis_device,struct net_device_context *net_device_ctx =netdev_priv (net);struct ndis_offload hwcaps;struct ndis_offload_params offloads; -unsigned int gso_max_size =GSO_MAX_SIZE ; +unsigned int gso_max_size =GSO_LEGACY_MAX_SIZE ;int ret;/* Find HW offload capabilities */
drivers/scsi/fcoe/fcoe.c +1 -1
@@ -667,7 +667,7 @@ static void fcoe_netdev_features_change(struct fc_lport *lport,if (netdev->features &NETIF_F_FSO ) { lport->seq_offload =1 ; - lport->lso_max = netdev->gso_max_size; + lport->lso_max =min (netdev->gso_max_size,GSO_LEGACY_MAX_SIZE );FCOE_NETDEV_DBG (netdev,"Supports LSO for max len 0x%x\n" , lport->lso_max); }else {
include/linux/netdevice.h +3 -1
@@ -2272,7 +2272,9 @@ struct net_device {const struct rtnl_link_ops *rtnl_link_ops;/* for setting kernel sock attribute on TCP connection setup */ -#define GSO_MAX_SIZE 65536 +#define GSO_LEGACY_MAX_SIZE 65536u +#define GSO_MAX_SIZE UINT_MAX +unsigned int gso_max_size;#define TSO_LEGACY_MAX_SIZE 65536#define TSO_MAX_SIZE UINT_MAX
net/bpf/test_run.c +1 -1
@@ -1001,7 +1001,7 @@ static int convert___skb_to_skb(struct sk_buff *skb, struct __sk_buff *__skb) cb->pkt_len = skb->len; }else {if (__skb->wire_len < skb->len || - __skb->wire_len >GSO_MAX_SIZE ) + __skb->wire_len >GSO_LEGACY_MAX_SIZE )return -EINVAL ; cb->pkt_len = __skb->wire_len; }
net/core/dev.c +4 -3
@@ -2998,11 +2998,12 @@ EXPORT_SYMBOL(netif_set_real_num_queues);* @size: max skb->len of a TSO frame * * Set the limit on the size of TSO super-frames the device can handle. -* Unless explicitly set the stack will assume the value of %GSO_MAX_SIZE. +* Unless explicitly set the stack will assume the value of +* %GSO_LEGACY_MAX_SIZE. */ void netif_set_tso_max_size (struct net_device *dev,unsigned int size) { - dev->tso_max_size = size; + dev->tso_max_size =min (GSO_MAX_SIZE , size);if (size <READ_ONCE (dev->gso_max_size))netif_set_gso_max_size (dev, size); }
@@ -10595,7 +10596,7 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,dev_net_set (dev, &init_net); - dev->gso_max_size =GSO_MAX_SIZE ; + dev->gso_max_size =GSO_LEGACY_MAX_SIZE ; dev->gso_max_segs =GSO_MAX_SEGS ; dev->gro_max_size =GRO_MAX_SIZE ; dev->tso_max_size =TSO_LEGACY_MAX_SIZE ;
net/core/rtnetlink.c +1 -1
@@ -2817,7 +2817,7 @@ static int do_setlink(const struct sk_buff *skb,if (tb[IFLA_GSO_MAX_SIZE ]) {u32 max_size =nla_get_u32 (tb[IFLA_GSO_MAX_SIZE ]); -if (max_size >GSO_MAX_SIZE || max_size > dev->tso_max_size) { +if (max_size > dev->tso_max_size) { err = -EINVAL ; goto errout; }
net/core/sock.c +14 -0
@@ -2293,6 +2293,19 @@ void sk_free_unlock_clone(struct sock *sk) }EXPORT_SYMBOL_GPL (sk_free_unlock_clone); +static void sk_trim_gso_size (struct sock *sk) +{ +if (sk->sk_gso_max_size <=GSO_LEGACY_MAX_SIZE ) +return ; +#if IS_ENABLED (CONFIG_IPV6 ) +if (sk->sk_family ==AF_INET6 && +sk_is_tcp (sk) && + !ipv6_addr_v4mapped (&sk->sk_v6_rcv_saddr)) +return ; +#endif + sk->sk_gso_max_size =GSO_LEGACY_MAX_SIZE ; +} +void sk_setup_caps (struct sock *sk,struct dst_entry *dst) {u32 max_segs =1 ;
@@ -2312,6 +2325,7 @@ void sk_setup_caps(struct sock *sk, struct dst_entry *dst) sk->sk_route_caps |=NETIF_F_SG |NETIF_F_HW_CSUM ;/* pairs with the WRITE_ONCE() in netif_set_gso_max_size() */ sk->sk_gso_max_size =READ_ONCE (dst->dev->gso_max_size); +sk_trim_gso_size (sk); sk->sk_gso_max_size -= (MAX_TCP_HEADER +1 );/* pairs with the WRITE_ONCE() in netif_set_gso_max_segs() */ max_segs =max_t (u32,READ_ONCE (dst->dev->gso_max_segs),1 );
net/ipv4/tcp_bbr.c +1 -1
@@ -310,7 +310,7 @@ static u32 bbr_tso_segs_goal(struct sock *sk)*/ bytes = min_t(unsigned long, sk->sk_pacing_rate >>READ_ONCE (sk->sk_pacing_shift), -GSO_MAX_SIZE -1 -MAX_TCP_HEADER ); +GSO_LEGACY_MAX_SIZE -1 -MAX_TCP_HEADER ); segs =max_t (u32, bytes / tp->mss_cache,bbr_min_tso_segs (sk));return min (segs,0x7FU );
net/ipv4/tcp_output.c +1 -1
@@ -1553,7 +1553,7 @@ int tcp_fragment(struct sock *sk, enum tcp_queue tcp_queue,* SO_SNDBUF values. * Also allow first and last skb in retransmit queue to be split. */ - limit = sk->sk_sndbuf +2 *SKB_TRUESIZE (GSO_MAX_SIZE ); + limit = sk->sk_sndbuf +2 *SKB_TRUESIZE (GSO_LEGACY_MAX_SIZE ); if (unlikely((sk->sk_wmem_queued >> 1) > limit && tcp_queue != TCP_FRAG_IN_WRITE_QUEUE && skb != tcp_rtx_queue_head(sk) &&
net/sctp/output.c +2 -1
@@ -134,7 +134,8 @@ void sctp_packet_config(struct sctp_packet *packet, __u32 vtag,dst_hold (tp->dst);sk_setup_caps (sk, tp->dst); } - packet->max_size =sk_can_gso (sk) ?READ_ONCE (tp->dst->dev->gso_max_size) + packet->max_size =sk_can_gso (sk) ?min (READ_ONCE (tp->dst->dev->gso_max_size), +GSO_LEGACY_MAX_SIZE ) : asoc->pathmtu;rcu_read_unlock (); }
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 3/13 net: limit GSO_MAX_SIZE to 524280 bytes
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
Make sure we will not overflow shinfo->gso_segs
Minimal TCP MSS size is 8 bytes, and shinfo->gso_segs is a 16bit field.
TCP_MIN_GSO_SIZE is currently defined in include/net/tcp.h, it seems cleaner to not bring tcp details into include/linux/netdevice.h
--- include/linux/netdevice.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
include/linux/netdevice.h +5 -2
@@ -2272,14 +2272,17 @@ struct net_device {const struct rtnl_link_ops *rtnl_link_ops;/* for setting kernel sock attribute on TCP connection setup */ +#define GSO_MAX_SEGS 65535u#define GSO_LEGACY_MAX_SIZE 65536u -#define GSO_MAX_SIZE UINT_MAX +/* TCP minimal MSS is 8 (TCP_MIN_GSO_SIZE), +* and shinfo->gso_segs is a 16bit field. +*/ +#define GSO_MAX_SIZE (8 * GSO_MAX_SEGS)unsigned int gso_max_size;#define TSO_LEGACY_MAX_SIZE 65536#define TSO_MAX_SIZE UINT_MAXunsigned int tso_max_size; -#define GSO_MAX_SEGS 65535u16 gso_max_segs;#define TSO_MAX_SEGS U16_MAXu16 tso_max_segs;
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 4/13 tcp_cubic: make hystart_ack_delay() aware of BIG TCP
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
hystart_ack_delay() had the assumption that a TSO packet would not be bigger than GSO_MAX_SIZE.
This will no longer be true.
We should use sk->sk_gso_max_size instead.
This reduces chances of spurious Hystart ACK train detections.
--- net/ipv4/tcp_cubic.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/ipv4/tcp_cubic.c +2 -2
@@ -372,7 +372,7 @@ static void cubictcp_state(struct sock *sk, u8 new_state)* We apply another 100% factor because @rate is doubled at this point. * We cap the cushion to 1ms. */ -static u32 hystart_ack_delay (struct sock *sk) +static u32 hystart_ack_delay (const struct sock *sk) {unsigned long rate;
@@ -380,7 +380,7 @@ static u32 hystart_ack_delay(struct sock *sk)if (!rate)return 0 ;return min_t (u64,USEC_PER_MSEC , -div64_ul ((u64 )GSO_MAX_SIZE *4 *USEC_PER_SEC , rate)); +div64_ul ((u64 )sk->sk_gso_max_size *4 *USEC_PER_SEC , rate)); }static void hystart_update (struct sock *sk,u32 delay)
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 5/13 ipv6: add struct hop_jumbo_hdr definition
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
Following patches will need to add and remove local IPv6 jumbogram options to enable BIG TCP.
--- include/net/ipv6.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
include/net/ipv6.h +11 -0
@@ -151,6 +151,17 @@ struct frag_hdr {__be32 identification; }; +/* +* Jumbo payload option, as described in RFC 2675 2. +*/ +struct hop_jumbo_hdr { +u8 nexthdr; +u8 hdrlen; +u8 tlv_type;/* IPV6_TLV_JUMBO, 0xC2 */ +u8 tlv_len;/* 4 */ +__be32 jumbo_payload_len; +}; +#define IP6_MF 0x0001#define IP6_OFFSET 0xFFF8
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 6/13 ipv6/gso: remove temporary HBH/jumbo header
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
ipv6 tcp and gro stacks will soon be able to build big TCP packets, with an added temporary Hop By Hop header.
If GSO is involved for these large packets, we need to remove the temporary HBH header before segmentation happens.
v2: perform HBH removal from ipv6_gso_segment() instead of
skb_segment() (Alexander feedback)
--- include/net/ipv6.h | 33 +++++++++++++++++++++++++++++++++ net/ipv6/ip6_offload.c | 24 +++++++++++++++++++++++- 2 files changed, 56 insertions(+), 1 deletion(-)
include/net/ipv6.h +33 -0
@@ -467,6 +467,39 @@ bool ipv6_opt_accepted(const struct sock *sk, const struct sk_buff *skb,struct ipv6_txoptions *ipv6_update_options (struct sock *sk,struct ipv6_txoptions *opt); +/* This helper is specialized for BIG TCP needs. +* It assumes the hop_jumbo_hdr will immediately follow the IPV6 header. +* It assumes headers are already in skb->head. +* Returns 0, or IPPROTO_TCP if a BIG TCP packet is there. +*/ +static inline int ipv6_has_hopopt_jumbo (const struct sk_buff *skb) +{ +const struct hop_jumbo_hdr *jhdr; +const struct ipv6hdr *nhdr; + +if (likely (skb->len <=GRO_MAX_SIZE )) +return 0 ; + +if (skb->protocol !=htons (ETH_P_IPV6 )) +return 0 ; + +if (skb_network_offset (skb) + +sizeof (struct ipv6hdr ) + +sizeof (struct hop_jumbo_hdr ) >skb_headlen (skb)) +return 0 ; + + nhdr =ipv6_hdr (skb); + +if (nhdr->nexthdr !=NEXTHDR_HOP ) +return 0 ; + + jhdr = (const struct hop_jumbo_hdr *) (nhdr +1 ); +if (jhdr->tlv_type !=IPV6_TLV_JUMBO || jhdr->hdrlen !=0 || + jhdr->nexthdr !=IPPROTO_TCP ) +return 0 ; +return jhdr->nexthdr; +} +static inline bool ipv6_accept_ra (struct inet6_dev *idev) {/* If forwarding is enabled, RA are not accepted unless the special
net/ipv6/ip6_offload.c +23 -1
@@ -77,7 +77,7 @@ static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb,struct sk_buff *segs =ERR_PTR (-EINVAL );struct ipv6hdr *ipv6h;const struct net_offload *ops; -int proto; +int proto, nexthdr;struct frag_hdr *fptr;unsigned int payload_len;u8 *prevhdr;
@@ -87,6 +87,28 @@ static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb,bool gso_partial;skb_reset_network_header (skb); + nexthdr =ipv6_has_hopopt_jumbo (skb); +if (nexthdr) { +const int hophdr_len =sizeof (struct hop_jumbo_hdr ); +int err; + + err =skb_cow_head (skb,0 ); +if (err <0 ) +return ERR_PTR (err); + +/* remove the HBH header. +* Layout: [Ethernet header][IPv6 header][HBH][TCP header] +*/ +memmove (skb_mac_header (skb) + hophdr_len, +skb_mac_header (skb), +ETH_HLEN +sizeof (struct ipv6hdr )); + skb->data += hophdr_len; + skb->len -= hophdr_len; + skb->network_header += hophdr_len; + skb->mac_header += hophdr_len; + ipv6h = (struct ipv6hdr *)skb->data; + ipv6h->nexthdr = nexthdr; + } nhoff =skb_network_header (skb) -skb_mac_header (skb);if (unlikely (!pskb_may_pull (skb,sizeof (*ipv6h)))) goto out;
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 7/13 ipv6/gro: insert temporary HBH/jumbo header
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
Following patch will add GRO_IPV6_MAX_SIZE, allowing gro to build BIG TCP ipv6 packets (bigger than 64K).
This patch changes ipv6_gro_complete() to insert a HBH/jumbo header so that resulting packet can go through IPv6/TCP stacks.
--- net/ipv6/ip6_offload.c | 32 ++++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-)
net/ipv6/ip6_offload.c +30 -2
@@ -342,15 +342,43 @@ static struct sk_buff *ip4ip6_gro_receive(struct list_head *head, INDIRECT_CALLABLE_SCOPE int ipv6_gro_complete(struct sk_buff *skb, int nhoff) {const struct net_offload *ops; -struct ipv6hdr *iph = (struct ipv6hdr *)(skb->data + nhoff); +struct ipv6hdr *iph;int err = -ENOSYS ; +u32 payload_len;if (skb->encapsulation) {skb_set_inner_protocol (skb,cpu_to_be16 (ETH_P_IPV6 ));skb_set_inner_network_header (skb, nhoff); } - iph->payload_len =htons (skb->len - nhoff -sizeof (*iph)); + payload_len = skb->len - nhoff -sizeof (*iph); +if (unlikely (payload_len >IPV6_MAXPLEN )) { +struct hop_jumbo_hdr *hop_jumbo; +int hoplen =sizeof (*hop_jumbo); + +/* Move network header left */ +memmove (skb_mac_header (skb) - hoplen,skb_mac_header (skb), + skb->transport_header - skb->mac_header); + skb->data -= hoplen; + skb->len += hoplen; + skb->mac_header -= hoplen; + skb->network_header -= hoplen; + iph = (struct ipv6hdr *)(skb->data + nhoff); + hop_jumbo = (struct hop_jumbo_hdr *)(iph +1 ); + +/* Build hop-by-hop options */ + hop_jumbo->nexthdr = iph->nexthdr; + hop_jumbo->hdrlen =0 ; + hop_jumbo->tlv_type =IPV6_TLV_JUMBO ; + hop_jumbo->tlv_len =4 ; + hop_jumbo->jumbo_payload_len =htonl (payload_len + hoplen); + + iph->nexthdr =NEXTHDR_HOP ; + iph->payload_len =0 ; + }else { + iph = (struct ipv6hdr *)(skb->data + nhoff); + iph->payload_len =htons (payload_len); + } nhoff +=sizeof (*iph) +ipv6_exthdrs_len (iph, &ops);if (WARN_ON (!ops || !ops->callbacks.gro_complete))
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 8/13 net: allow gro_max_size to exceed 65536
In reply to Eric DumazetFrom: Alexander Duyck <[email protected]>
Allow the gro_max_size to exceed a value larger than 65536.
There weren't really any external limitations that prevented this other than the fact that IPv4 only supports a 16 bit length field. Since we have the option of adding a hop-by-hop header for IPv6 we can allow IPv6 to exceed this value and for IPv4 and non-TCP flows we can cap things at 65536 via a constant rather than relying on gro_max_size.
[edumazet] limit GRO_MAX_SIZE to (8 * 65535) to avoid overflows.
--- drivers/net/ethernet/mellanox/mlx5/core/en_rx.c | 2 +- include/linux/netdevice.h | 6 +++++- include/net/ipv6.h | 2 +- net/core/dev.c | 2 +- net/core/gro.c | 8 ++++++++ net/core/rtnetlink.c | 8 -------- 6 files changed, 16 insertions(+), 12 deletions(-)
drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +1 -1
@@ -2038,7 +2038,7 @@ mlx5e_hw_gro_skb_has_enough_space(struct sk_buff *skb, u16 data_bcnt) {int nr_frags =skb_shinfo (skb)->nr_frags; -return PAGE_SIZE * nr_frags + data_bcnt <=GRO_MAX_SIZE ; +return PAGE_SIZE * nr_frags + data_bcnt <=GRO_LEGACY_MAX_SIZE ; } static void
include/linux/netdevice.h +5 -1
@@ -2161,7 +2161,11 @@ struct net_device {struct bpf_prog __rcu *xdp_prog;unsigned long gro_flush_timeout;int napi_defer_hard_irqs; -#define GRO_MAX_SIZE 65536 +#define GRO_LEGACY_MAX_SIZE 65536u +/* TCP minimal MSS is 8 (TCP_MIN_GSO_SIZE), +* and shinfo->gso_segs is a 16bit field. +*/ +#define GRO_MAX_SIZE (8 * 65535u)unsigned int gro_max_size;rx_handler_func_t __rcu *rx_handler;void __rcu *rx_handler_data;
include/net/ipv6.h +1 -1
@@ -477,7 +477,7 @@ static inline int ipv6_has_hopopt_jumbo(const struct sk_buff *skb)const struct hop_jumbo_hdr *jhdr;const struct ipv6hdr *nhdr; -if (likely (skb->len <=GRO_MAX_SIZE )) +if (likely (skb->len <=GRO_LEGACY_MAX_SIZE ))return 0 ;if (skb->protocol !=htons (ETH_P_IPV6 ))
net/core/dev.c +1 -1
@@ -10598,7 +10598,7 @@ struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name, dev->gso_max_size =GSO_LEGACY_MAX_SIZE ; dev->gso_max_segs =GSO_MAX_SEGS ; - dev->gro_max_size =GRO_MAX_SIZE ; + dev->gro_max_size =GRO_LEGACY_MAX_SIZE ; dev->tso_max_size =TSO_LEGACY_MAX_SIZE ; dev->tso_max_segs =TSO_MAX_SEGS ; dev->upper_level =1 ;
net/core/gro.c +8 -0
@@ -167,6 +167,14 @@ int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb)if (unlikely (p->len + len >= gro_max_size ||NAPI_GRO_CB (skb)->flush))return -E2BIG ; +if (unlikely (p->len + len >=GRO_LEGACY_MAX_SIZE )) { +if (p->protocol !=htons (ETH_P_IPV6 ) || +skb_headroom (p) <sizeof (struct hop_jumbo_hdr ) || +ipv6_hdr (p)->nexthdr !=IPPROTO_TCP || + p->encapsulation) +return -E2BIG ; + } + lp =NAPI_GRO_CB (p)->last; pinfo =skb_shinfo (lp);
net/core/rtnetlink.c +0 -8
@@ -2360,14 +2360,6 @@ static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[], } } -if (tb[IFLA_GRO_MAX_SIZE ]) { -u32 gro_max_size =nla_get_u32 (tb[IFLA_GRO_MAX_SIZE ]); - -if (gro_max_size >GRO_MAX_SIZE ) { -NL_SET_ERR_MSG (extack,"too big gro_max_size" ); -return -EINVAL ; - } - }return 0 ; }
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 9/13 ipv6: Add hop-by-hop header to jumbograms in ip6_output
In reply to Eric DumazetFrom: Coco Li <[email protected]>
Instead of simply forcing a 0 payload_len in IPv6 header, implement RFC 2675 and insert a custom extension header.
Note that only TCP stack is currently potentially generating jumbograms, and that this extension header is purely local, it wont be sent on a physical link.
This is needed so that packet capture (tcpdump and friends) can properly dissect these large packets.
--- include/linux/ipv6.h | 1 + net/ipv6/ip6_output.c | 22 ++++++++++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-)
include/linux/ipv6.h +1 -0
@@ -145,6 +145,7 @@ struct inet6_skb_parm {#define IP6SKB_L3SLAVE 64#define IP6SKB_JUMBOGRAM 128#define IP6SKB_SEG6 256 +#define IP6SKB_FAKEJUMBO 512 };#if defined(CONFIG_NET_L3_MASTER_DEV )
net/ipv6/ip6_output.c +20 -2
@@ -182,7 +182,9 @@ static int __ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff#endif mtu =ip6_skb_dst_mtu (skb); -if (skb_is_gso (skb) && !skb_gso_validate_network_len (skb, mtu)) +if (skb_is_gso (skb) && + !(IP6CB (skb)->flags &IP6SKB_FAKEJUMBO ) && + !skb_gso_validate_network_len (skb, mtu))return ip6_finish_output_gso_slowpath_drop (net, sk, skb, mtu); if ((skb->len > mtu && !skb_is_gso(skb)) ||
@@ -252,6 +254,8 @@ int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,struct dst_entry *dst =skb_dst (skb);struct net_device *dev = dst->dev;struct inet6_dev *idev =ip6_dst_idev (dst); +struct hop_jumbo_hdr *hop_jumbo; +int hoplen =sizeof (*hop_jumbo);unsigned int head_room;struct ipv6hdr *hdr;u8 proto = fl6->flowi6_proto;
@@ -259,7 +263,7 @@ int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,int hlimit =-1 ;u32 mtu; - head_room =sizeof (struct ipv6hdr ) +LL_RESERVED_SPACE (dev); + head_room =sizeof (struct ipv6hdr ) + hoplen +LL_RESERVED_SPACE (dev);if (opt) head_room += opt->opt_nflen + opt->opt_flen;
@@ -282,6 +286,20 @@ int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, &fl6->saddr); } +if (unlikely (seg_len >IPV6_MAXPLEN )) { + hop_jumbo =skb_push (skb, hoplen); + + hop_jumbo->nexthdr = proto; + hop_jumbo->hdrlen =0 ; + hop_jumbo->tlv_type =IPV6_TLV_JUMBO ; + hop_jumbo->tlv_len =4 ; + hop_jumbo->jumbo_payload_len =htonl (seg_len + hoplen); + + proto =IPPROTO_HOPOPTS ; + seg_len =0 ; +IP6CB (skb)->flags |=IP6SKB_FAKEJUMBO ; + } +skb_push (skb,sizeof (struct ipv6hdr ));skb_reset_network_header (skb); hdr =ipv6_hdr (skb);
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 10/13 net: loopback: enable BIG TCP packets
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
Set the driver limit to GSO_MAX_SIZE (512 KB).
This allows the admin/user to set a GSO limit up to this value.
Tested:
ip link set dev lo gso_max_size 200000 netperf -H ::1 -t TCP_RR -l 100 -- -r 80000,80000 &
tcpdump shows :
18:28:42.962116 IP6 ::1 > ::1: HBH 40051 > 63780: Flags [P.], seq 3626480001:3626560001, ack 3626560001, win 17743, options [nop,nop,TS val 3771179265 ecr 3771179265], length 80000 18:28:42.962138 IP6 ::1.63780 > ::1.40051: Flags [.], ack 3626560001, win 17743, options [nop,nop,TS val 3771179265 ecr 3771179265], length 0 18:28:42.962152 IP6 ::1 > ::1: HBH 63780 > 40051: Flags [P.], seq 3626560001:3626640001, ack 3626560001, win 17743, options [nop,nop,TS val 3771179265 ecr 3771179265], length 80000 18:28:42.962157 IP6 ::1.40051 > ::1.63780: Flags [.], ack 3626640001, win 17743, options [nop,nop,TS val 3771179265 ecr 3771179265], length 0 18:28:42.962180 IP6 ::1 > ::1: HBH 40051 > 63780: Flags [P.], seq 3626560001:3626640001, ack 3626640001, win 17743, options [nop,nop,TS val 3771179265 ecr 3771179265], length 80000 18:28:42.962214 IP6 ::1.63780 > ::1.40051: Flags [.], ack 3626640001, win 17743, options [nop,nop,TS val 3771179266 ecr 3771179265], length 0 18:28:42.962228 IP6 ::1 > ::1: HBH 63780 > 40051: Flags [P.], seq 3626640001:3626720001, ack 3626640001, win 17743, options [nop,nop,TS val 3771179266 ecr 3771179265], length 80000 18:28:42.962233 IP6 ::1.40051 > ::1.63780: Flags [.], ack 3626720001, win 17743, options [nop,nop,TS val 3771179266 ecr 3771179266], length 0
--- drivers/net/loopback.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/net/loopback.c +2 -0
@@ -191,6 +191,8 @@ static void gen_lo_setup(struct net_device *dev, dev->netdev_ops = dev_ops; dev->needs_free_netdev = true; dev->priv_destructor = dev_destructor; + +netif_set_tso_max_size (dev,GSO_MAX_SIZE ); }/* The loopback device is special. There is only one instance
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 11/13 veth: enable BIG TCP packets
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
Set the TSO driver limit to GSO_MAX_SIZE (512 KB).
This allows the admin/user to set a GSO limit up to this value.
ip link set dev veth10 gso_max_size 200000
--- drivers/net/veth.c | 1 + 1 file changed, 1 insertion(+)
drivers/net/veth.c +1 -0
@@ -1647,6 +1647,7 @@ static void veth_setup(struct net_device *dev) dev->hw_features =VETH_FEATURES ; dev->hw_enc_features =VETH_FEATURES ; dev->mpls_features =NETIF_F_HW_CSUM |NETIF_F_GSO_SOFTWARE ; +netif_set_tso_max_size (dev,GSO_MAX_SIZE ); }/*
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 12/13 mlx4: support BIG TCP packets
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
mlx4 supports LSOv2 just fine.
IPv6 stack inserts a temporary Hop-by-Hop header
with JUMBO TLV for big packets.
We need to ignore the HBH header when populating TX descriptor.
Tested:
Before: (not enabling bigger TSO/GRO packets)
ip link set dev eth0 gso_max_size 65536 gro_max_size 65536
netperf -H lpaa18 -t TCP_RR -T2,2 -l 10 -Cc -- -r 70000,70000
MIGRATED TCP REQUEST/RESPONSE TEST from ::0 (::) port 0 AF_INET6 to lpaa18.prod.google.com () port 0 AF_INET6 : first burst 0 : cpu bind Local /Remote
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem Send Recv Size Size Time Rate local remote local remote bytes bytes bytes bytes secs. per sec % S % S us/Tr us/Tr
262144 540000 70000 70000 10.00 6591.45 0.86 1.34 62.490 97.446
262144 540000
After: (enabling bigger TSO/GRO packets)
ip link set dev eth0 gso_max_size 185000 gro_max_size 185000
netperf -H lpaa18 -t TCP_RR -T2,2 -l 10 -Cc -- -r 70000,70000
MIGRATED TCP REQUEST/RESPONSE TEST from ::0 (::) port 0 AF_INET6 to lpaa18.prod.google.com () port 0 AF_INET6 : first burst 0 : cpu bind Local /Remote
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem Send Recv Size Size Time Rate local remote local remote bytes bytes bytes bytes secs. per sec % S % S us/Tr us/Tr
262144 540000 70000 70000 10.00 8383.95 0.95 1.01 54.432 57.584
262144 540000
--- .../net/ethernet/mellanox/mlx4/en_netdev.c | 3 ++ drivers/net/ethernet/mellanox/mlx4/en_tx.c | 47 +++++++++++++++---- 2 files changed, 41 insertions(+), 9 deletions(-)
drivers/net/ethernet/mellanox/mlx4/en_netdev.c +3 -0
@@ -3417,6 +3417,9 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, dev->min_mtu =ETH_MIN_MTU ; dev->max_mtu = priv->max_mtu; +/* supports LSOv2 packets. */ +netif_set_tso_max_size (dev,GSO_MAX_SIZE ); + mdev->pndev[port] = dev; mdev->upper[port] =NULL ;
drivers/net/ethernet/mellanox/mlx4/en_tx.c +38 -9
103 lines not on this page · raw message
Signature · 1 line
2.36.0.550.gb090851708-goog
PATCH v7 13/13 mlx5: support BIG TCP packets
In reply to Eric DumazetFrom: Eric Dumazet <[email protected]>
mlx5 supports LSOv2.
IPv6 gro/tcp stacks insert a temporary Hop-by-Hop header with JUMBO TLV for big packets.
We need to ignore/skip this HBH header when populating TX descriptor.
Note that ipv6_has_hopopt_jumbo() only recognizes very specific packet layout, thus mlx5e_sq_xmit_wqe() is taking care of this layout only.
v7: adopt unsafe_memcpy() and MLX5_UNSAFE_MEMCPY_DISCLAIMER
v2: clear hopbyhop in mlx5e_tx_get_gso_ihs()
v4: fix compile error for CONFIG_MLX5_CORE_IPOIB=y
--- .../net/ethernet/mellanox/mlx5/core/en_main.c | 1 + .../net/ethernet/mellanox/mlx5/core/en_tx.c | 111 ++++++++++++++---- 2 files changed, 89 insertions(+), 23 deletions(-)
drivers/net/ethernet/mellanox/mlx5/core/en_main.c +1 -0
@@ -4920,6 +4920,7 @@ static void mlx5e_build_nic_netdev(struct net_device *netdev) netdev->priv_flags |=IFF_UNICAST_FLT ; +netif_set_tso_max_size (netdev,GSO_MAX_SIZE );mlx5e_set_netdev_dev_addr (netdev);mlx5e_ipsec_build_netdev (priv);mlx5e_ktls_build_netdev (priv);
drivers/net/ethernet/mellanox/mlx5/core/en_tx.c +88 -23
197 lines not on this page · raw message
Signature · 1 line
2.36.0.550.gb090851708-goog
This series was applied to netdev/net-next.git (master) by David S. Miller <[email protected]>:
Hello:
This series was applied to netdev/net-next.git (master) by David S. Miller <[email protected]>:
Quoted 9 lines · On Fri, 13 May 2022 11:33:55 -0700 you wrote:
From: Eric Dumazet <[email protected]>
This series implements BIG TCP as presented in netdev
0x15:https://netdevconf.info/0x15/session.html?BIG-TCP
Jonathan Corbet made a nice summary: https://lwn.net/Articles/884104/
[...]
Here is the summary with links:
- [v7,net-next,01/13] net: add IFLA_TSO_{MAX_SIZE|SEGS} attributes
https://git.kernel.org/netdev/net-next/c/89527be8d8d6 - [v7,net-next,02/13] net: allow gso_max_size to exceed 65536 https://git.kernel.org/netdev/net-next/c/7c4e983c4f3c - [v7,net-next,03/13] net: limit GSO_MAX_SIZE to 524280 bytes https://git.kernel.org/netdev/net-next/c/34b92e8d19da - [v7,net-next,04/13] tcp_cubic: make hystart_ack_delay() aware of BIG TCP https://git.kernel.org/netdev/net-next/c/9957b38b5e7a - [v7,net-next,05/13] ipv6: add struct hop_jumbo_hdr definition https://git.kernel.org/netdev/net-next/c/7c96d8ec96bb - [v7,net-next,06/13] ipv6/gso: remove temporary HBH/jumbo header https://git.kernel.org/netdev/net-next/c/09f3d1a3a52c - [v7,net-next,07/13] ipv6/gro: insert temporary HBH/jumbo header https://git.kernel.org/netdev/net-next/c/81fbc812132c - [v7,net-next,08/13] net: allow gro_max_size to exceed 65536 https://git.kernel.org/netdev/net-next/c/0fe79f28bfaf - [v7,net-next,09/13] ipv6: Add hop-by-hop header to jumbograms in ip6_output https://git.kernel.org/netdev/net-next/c/80e425b61342 - [v7,net-next,10/13] net: loopback: enable BIG TCP packets https://git.kernel.org/netdev/net-next/c/d6f938ce52f9 - [v7,net-next,11/13] veth: enable BIG TCP packets https://git.kernel.org/netdev/net-next/c/d406099d6a15 - [v7,net-next,12/13] mlx4: support BIG TCP packets https://git.kernel.org/netdev/net-next/c/1169a64265c4 - [v7,net-next,13/13] mlx5: support BIG TCP packets https://git.kernel.org/netdev/net-next/c/de78960e025f
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html