// SPDX-License-Identifier: GPL-2.0-or-later#include <linux/skbuff.h>#include <linux/sctp.h>#include <net/gso.h>#include <net/gro.h> /** *	skb_eth_gso_segment - segmentation handler for ethernet protocols. *	@skb: buffer to segment *	@features: features for the output path (see dev->features) *	@type: Ethernet Protocol ID */struct sk_buff *skb_eth_gso_segment(struct sk_buff *skb,				    netdev_features_t features, __be16 type){	struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);	struct packet_offload *ptype; 	rcu_read_lock();	list_for_each_entry_rcu(ptype, &net_hotdata.offload_base, list) {		if (ptype->type == type && ptype->callbacks.gso_segment) {			segs = ptype->callbacks.gso_segment(skb, features);			break;		}	}	rcu_read_unlock(); 	return segs;}EXPORT_SYMBOL(skb_eth_gso_segment); /** *	skb_mac_gso_segment - mac layer segmentation handler. *	@skb: buffer to segment *	@features: features for the output path (see dev->features) */struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,				    netdev_features_t features){	struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);	struct packet_offload *ptype;	int vlan_depth = skb->mac_len;	__be16 type = skb_network_protocol(skb, &vlan_depth); 	if (unlikely(!type))		return ERR_PTR(-EINVAL); 	__skb_pull(skb, vlan_depth); 	rcu_read_lock();	list_for_each_entry_rcu(ptype, &net_hotdata.offload_base, list) {		if (ptype->type == type && ptype->callbacks.gso_segment) {			segs = ptype->callbacks.gso_segment(skb, features);			break;		}	}	rcu_read_unlock(); 	__skb_push(skb, skb->data - skb_mac_header(skb)); 	return segs;}EXPORT_SYMBOL(skb_mac_gso_segment);/* openvswitch calls this on rx path, so we need a different check. */static bool skb_needs_check(const struct sk_buff *skb, bool tx_path){	if (tx_path)		return skb->ip_summed != CHECKSUM_PARTIAL &&		       skb->ip_summed != CHECKSUM_UNNECESSARY; 	return skb->ip_summed == CHECKSUM_NONE;} /** *	__skb_gso_segment - Perform segmentation on skb. *	@skb: buffer to segment *	@features: features for the output path (see dev->features) *	@tx_path: whether it is called in TX path * *	This function segments the given skb and returns a list of segments. * *	It may return NULL if the skb requires no segmentation.  This is *	only possible when GSO is used for verifying header integrity. * *	Segmentation preserves SKB_GSO_CB_OFFSET bytes of previous skb cb. */struct sk_buff *__skb_gso_segment(struct sk_buff *skb,				  netdev_features_t features, bool tx_path){	struct sk_buff *segs; 	if (unlikely(skb_needs_check(skb, tx_path))) {		int err; 		/* We're going to init ->check field in TCP or UDP header */		err = skb_cow_head(skb, 0);		if (err < 0)			return ERR_PTR(err);	} 	/* Only report GSO partial support if it will enable us to	 * support segmentation on this frame without needing additional	 * work.	 */	if (features & NETIF_F_GSO_PARTIAL) {		netdev_features_t partial_features = NETIF_F_GSO_ROBUST;		struct net_device *dev = skb->dev; 		partial_features |= dev->features & dev->gso_partial_features;		if (!skb_gso_ok(skb, features | partial_features))			features &= ~NETIF_F_GSO_PARTIAL;	} 	BUILD_BUG_ON(SKB_GSO_CB_OFFSET +		     sizeof(*SKB_GSO_CB(skb)) > sizeof(skb->cb)); 	SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);	SKB_GSO_CB(skb)->encap_level = 0; 	skb_reset_mac_header(skb);	skb_reset_mac_len(skb); 	segs = skb_mac_gso_segment(skb, features); 	if (segs != skb && unlikely(skb_needs_check(skb, tx_path) && !IS_ERR(segs)))		skb_warn_bad_offload(skb); 	return segs;}EXPORT_SYMBOL(__skb_gso_segment); /** * skb_gso_transport_seglen - Return length of individual segments of a gso packet * * @skb: GSO skb * * skb_gso_transport_seglen is used to determine the real size of the * individual segments, including Layer4 headers (TCP/UDP). * * The MAC/L2 or network (IP, IPv6) headers are not accounted for. */static unsigned int skb_gso_transport_seglen(const struct sk_buff *skb){	const struct skb_shared_info *shinfo = skb_shinfo(skb);	unsigned int thlen = 0; 	if (skb->encapsulation) {		thlen = skb_inner_transport_header(skb) -			skb_transport_header(skb); 		if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))			thlen += inner_tcp_hdrlen(skb);	} else if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {		thlen = tcp_hdrlen(skb);	} else if (unlikely(skb_is_gso_sctp(skb))) {		thlen = sizeof(struct sctphdr);	} else if (shinfo->gso_type & SKB_GSO_UDP_L4) {		thlen = sizeof(struct udphdr);	}	/* UFO sets gso_size to the size of the fragmentation	 * payload, i.e. the size of the L4 (UDP) header is already	 * accounted for.	 */	return thlen + shinfo->gso_size;} /** * skb_gso_network_seglen - Return length of individual segments of a gso packet * * @skb: GSO skb * * skb_gso_network_seglen is used to determine the real size of the * individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP). * * The MAC/L2 header is not accounted for. */static unsigned int skb_gso_network_seglen(const struct sk_buff *skb){	unsigned int hdr_len = skb_transport_header(skb) -			       skb_network_header(skb); 	return hdr_len + skb_gso_transport_seglen(skb);} /** * skb_gso_mac_seglen - Return length of individual segments of a gso packet * * @skb: GSO skb * * skb_gso_mac_seglen is used to determine the real size of the * individual segments, including MAC/L2, Layer3 (IP, IPv6) and L4 * headers (TCP/UDP). */static unsigned int skb_gso_mac_seglen(const struct sk_buff *skb){	unsigned int hdr_len = skb_transport_header(skb) - skb_mac_header(skb); 	return hdr_len + skb_gso_transport_seglen(skb);} /** * skb_gso_size_check - check the skb size, considering GSO_BY_FRAGS * * There are a couple of instances where we have a GSO skb, and we * want to determine what size it would be after it is segmented. * * We might want to check: * -    L3+L4+payload size (e.g. IP forwarding) * - L2+L3+L4+payload size (e.g. sanity check before passing to driver) * * This is a helper to do that correctly considering GSO_BY_FRAGS. * * @skb: GSO skb * * @seg_len: The segmented length (from skb_gso_*_seglen). In the *           GSO_BY_FRAGS case this will be [header sizes + GSO_BY_FRAGS]. * * @max_len: The maximum permissible length. * * Returns true if the segmented length <= max length. */static inline bool skb_gso_size_check(const struct sk_buff *skb,				      unsigned int seg_len,				      unsigned int max_len) {	const struct skb_shared_info *shinfo = skb_shinfo(skb);	const struct sk_buff *iter; 	if (shinfo->gso_size != GSO_BY_FRAGS)		return seg_len <= max_len; 	/* Undo this so we can re-use header sizes */	seg_len -= GSO_BY_FRAGS; 	skb_walk_frags(skb, iter) {		if (seg_len + skb_headlen(iter) > max_len)			return false;	} 	return true;} /** * skb_gso_validate_network_len - Will a split GSO skb fit into a given MTU? * * @skb: GSO skb * @mtu: MTU to validate against * * skb_gso_validate_network_len validates if a given skb will fit a * wanted MTU once split. It considers L3 headers, L4 headers, and the * payload. */bool skb_gso_validate_network_len(const struct sk_buff *skb, unsigned int mtu){	return skb_gso_size_check(skb, skb_gso_network_seglen(skb), mtu);}EXPORT_SYMBOL_GPL(skb_gso_validate_network_len); /** * skb_gso_validate_mac_len - Will a split GSO skb fit in a given length? * * @skb: GSO skb * @len: length to validate against * * skb_gso_validate_mac_len validates if a given skb will fit a wanted * length once split, including L2, L3 and L4 headers and the payload. */bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len){	return skb_gso_size_check(skb, skb_gso_mac_seglen(skb), len);}EXPORT_SYMBOL_GPL(skb_gso_validate_mac_len);