net/core/gso.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 #include <linux/skbuff.h>
   3 #include <linux/sctp.h>
   4 #include <net/gso.h>
   5 #include <net/gro.h>
   6
   7 /**
   8  *      skb_eth_gso_segment - segmentation handler for ethernet protocols.
   9  *      @skb: buffer to segment
  10  *      @features: features for the output path (see dev->features)
  11  *      @type: Ethernet Protocol ID
  12  */
  13 struct sk_buff *skb_eth_gso_segment(struct sk_buff *skb,
  14                                     netdev_features_t features, __be16 type)
  15 {
  16         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
  17         struct packet_offload *ptype;
  18
  19         rcu_read_lock();
  20         list_for_each_entry_rcu(ptype, &net_hotdata.offload_base, list) {
  21                 if (ptype->type == type && ptype->callbacks.gso_segment) {
  22                         segs = ptype->callbacks.gso_segment(skb, features);
  23                         break;
  24                 }
  25         }
  26         rcu_read_unlock();
  27
  28         return segs;
  29 }
  30 EXPORT_SYMBOL(skb_eth_gso_segment);
  31
  32 /**
  33  *      skb_mac_gso_segment - mac layer segmentation handler.
  34  *      @skb: buffer to segment
  35  *      @features: features for the output path (see dev->features)
  36  */
  37 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
  38                                     netdev_features_t features)
  39 {
  40         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
  41         struct packet_offload *ptype;
  42         int vlan_depth = skb->mac_len;
  43         __be16 type = skb_network_protocol(skb, &vlan_depth);
  44
  45         if (unlikely(!type))
  46                 return ERR_PTR(-EINVAL);
  47
  48         __skb_pull(skb, vlan_depth);
  49
  50         rcu_read_lock();
  51         list_for_each_entry_rcu(ptype, &net_hotdata.offload_base, list) {
  52                 if (ptype->type == type && ptype->callbacks.gso_segment) {
  53                         segs = ptype->callbacks.gso_segment(skb, features);
  54                         break;
  55                 }
  56         }
  57         rcu_read_unlock();
  58
  59         __skb_push(skb, skb->data - skb_mac_header(skb));
  60
  61         return segs;
  62 }
  63 EXPORT_SYMBOL(skb_mac_gso_segment);
  64 /* openvswitch calls this on rx path, so we need a different check.
  65  */
  66 static bool skb_needs_check(const struct sk_buff *skb, bool tx_path)
  67 {
  68         if (tx_path)
  69                 return skb->ip_summed != CHECKSUM_PARTIAL &&
  70                        skb->ip_summed != CHECKSUM_UNNECESSARY;
  71
  72         return skb->ip_summed == CHECKSUM_NONE;
  73 }
  74
  75 /**
  76  *      __skb_gso_segment - Perform segmentation on skb.
  77  *      @skb: buffer to segment
  78  *      @features: features for the output path (see dev->features)
  79  *      @tx_path: whether it is called in TX path
  80  *
  81  *      This function segments the given skb and returns a list of segments.
  82  *
  83  *      It may return NULL if the skb requires no segmentation.  This is
  84  *      only possible when GSO is used for verifying header integrity.
  85  *
  86  *      Segmentation preserves SKB_GSO_CB_OFFSET bytes of previous skb cb.
  87  */
  88 struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
  89                                   netdev_features_t features, bool tx_path)
  90 {
  91         struct sk_buff *segs;
  92
  93         if (unlikely(skb_needs_check(skb, tx_path))) {
  94                 int err;
  95
  96                 /* We're going to init ->check field in TCP or UDP header */
  97                 err = skb_cow_head(skb, 0);
  98                 if (err < 0)
  99                         return ERR_PTR(err);
 100         }
 101
 102         /* Only report GSO partial support if it will enable us to
 103          * support segmentation on this frame without needing additional
 104          * work.
 105          */
 106         if (features & NETIF_F_GSO_PARTIAL) {
 107                 netdev_features_t partial_features = NETIF_F_GSO_ROBUST;
 108                 struct net_device *dev = skb->dev;
 109
 110                 partial_features |= dev->features & dev->gso_partial_features;
 111                 if (!skb_gso_ok(skb, features | partial_features))
 112                         features &= ~NETIF_F_GSO_PARTIAL;
 113         }
 114
 115         BUILD_BUG_ON(SKB_GSO_CB_OFFSET +
 116                      sizeof(*SKB_GSO_CB(skb)) > sizeof(skb->cb));
 117
 118         SKB_GSO_CB(skb)->mac_offset = skb_headroom(skb);
 119         SKB_GSO_CB(skb)->encap_level = 0;
 120
 121         skb_reset_mac_header(skb);
 122         skb_reset_mac_len(skb);
 123
 124         segs = skb_mac_gso_segment(skb, features);
 125
 126         if (segs != skb && unlikely(skb_needs_check(skb, tx_path) && !IS_ERR(segs)))
 127                 skb_warn_bad_offload(skb);
 128
 129         return segs;
 130 }
 131 EXPORT_SYMBOL(__skb_gso_segment);
 132
 133 /**
 134  * skb_gso_transport_seglen - Return length of individual segments of a gso packet
 135  *
 136  * @skb: GSO skb
 137  *
 138  * skb_gso_transport_seglen is used to determine the real size of the
 139  * individual segments, including Layer4 headers (TCP/UDP).
 140  *
 141  * The MAC/L2 or network (IP, IPv6) headers are not accounted for.
 142  */
 143 static unsigned int skb_gso_transport_seglen(const struct sk_buff *skb)
 144 {
 145         const struct skb_shared_info *shinfo = skb_shinfo(skb);
 146         unsigned int thlen = 0;
 147
 148         if (skb->encapsulation) {
 149                 thlen = skb_inner_transport_header(skb) -
 150                         skb_transport_header(skb);
 151
 152                 if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
 153                         thlen += inner_tcp_hdrlen(skb);
 154         } else if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
 155                 thlen = tcp_hdrlen(skb);
 156         } else if (unlikely(skb_is_gso_sctp(skb))) {
 157                 thlen = sizeof(struct sctphdr);
 158         } else if (shinfo->gso_type & SKB_GSO_UDP_L4) {
 159                 thlen = sizeof(struct udphdr);
 160         }
 161         /* UFO sets gso_size to the size of the fragmentation
 162          * payload, i.e. the size of the L4 (UDP) header is already
 163          * accounted for.
 164          */
 165         return thlen + shinfo->gso_size;
 166 }
 167
 168 /**
 169  * skb_gso_network_seglen - Return length of individual segments of a gso packet
 170  *
 171  * @skb: GSO skb
 172  *
 173  * skb_gso_network_seglen is used to determine the real size of the
 174  * individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP).
 175  *
 176  * The MAC/L2 header is not accounted for.
 177  */
 178 static unsigned int skb_gso_network_seglen(const struct sk_buff *skb)
 179 {
 180         unsigned int hdr_len = skb_transport_header(skb) -
 181                                skb_network_header(skb);
 182
 183         return hdr_len + skb_gso_transport_seglen(skb);
 184 }
 185
 186 /**
 187  * skb_gso_mac_seglen - Return length of individual segments of a gso packet
 188  *
 189  * @skb: GSO skb
 190  *
 191  * skb_gso_mac_seglen is used to determine the real size of the
 192  * individual segments, including MAC/L2, Layer3 (IP, IPv6) and L4
 193  * headers (TCP/UDP).
 194  */
 195 static unsigned int skb_gso_mac_seglen(const struct sk_buff *skb)
 196 {
 197         unsigned int hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
 198
 199         return hdr_len + skb_gso_transport_seglen(skb);
 200 }
 201
 202 /**
 203  * skb_gso_size_check - check the skb size, considering GSO_BY_FRAGS
 204  *
 205  * There are a couple of instances where we have a GSO skb, and we
 206  * want to determine what size it would be after it is segmented.
 207  *
 208  * We might want to check:
 209  * -    L3+L4+payload size (e.g. IP forwarding)
 210  * - L2+L3+L4+payload size (e.g. sanity check before passing to driver)
 211  *
 212  * This is a helper to do that correctly considering GSO_BY_FRAGS.
 213  *
 214  * @skb: GSO skb
 215  *
 216  * @seg_len: The segmented length (from skb_gso_*_seglen). In the
 217  *           GSO_BY_FRAGS case this will be [header sizes + GSO_BY_FRAGS].
 218  *
 219  * @max_len: The maximum permissible length.
 220  *
 221  * Returns true if the segmented length <= max length.
 222  */
 223 static inline bool skb_gso_size_check(const struct sk_buff *skb,
 224                                       unsigned int seg_len,
 225                                       unsigned int max_len) {
 226         const struct skb_shared_info *shinfo = skb_shinfo(skb);
 227         const struct sk_buff *iter;
 228
 229         if (shinfo->gso_size != GSO_BY_FRAGS)
 230                 return seg_len <= max_len;
 231
 232         /* Undo this so we can re-use header sizes */
 233         seg_len -= GSO_BY_FRAGS;
 234
 235         skb_walk_frags(skb, iter) {
 236                 if (seg_len + skb_headlen(iter) > max_len)
 237                         return false;
 238         }
 239
 240         return true;
 241 }
 242
 243 /**
 244  * skb_gso_validate_network_len - Will a split GSO skb fit into a given MTU?
 245  *
 246  * @skb: GSO skb
 247  * @mtu: MTU to validate against
 248  *
 249  * skb_gso_validate_network_len validates if a given skb will fit a
 250  * wanted MTU once split. It considers L3 headers, L4 headers, and the
 251  * payload.
 252  */
 253 bool skb_gso_validate_network_len(const struct sk_buff *skb, unsigned int mtu)
 254 {
 255         return skb_gso_size_check(skb, skb_gso_network_seglen(skb), mtu);
 256 }
 257 EXPORT_SYMBOL_GPL(skb_gso_validate_network_len);
 258
 259 /**
 260  * skb_gso_validate_mac_len - Will a split GSO skb fit in a given length?
 261  *
 262  * @skb: GSO skb
 263  * @len: length to validate against
 264  *
 265  * skb_gso_validate_mac_len validates if a given skb will fit a wanted
 266  * length once split, including L2, L3 and L4 headers and the payload.
 267  */
 268 bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len)
 269 {
 270         return skb_gso_size_check(skb, skb_gso_mac_seglen(skb), len);
 271 }
 272 EXPORT_SYMBOL_GPL(skb_gso_validate_mac_len);
 273