Quellcode-Bibliothek tcp_offload.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * IPV4 GSO/GRO offload support
 * Linux INET implementation
 *
 * TCPv4 GSO/GRO support
 */

#include <linux/indirect_call_wrapper.h>
#include <linux/skbuff.h>
#include <net/gro.h>
#include <net/gso.h>
#include <net/tcp.h>
#include <net/protocol.h>

static void tcp_gso_tstamp(struct sk_buff *skb, struct sk_buff *gso_skb,
      unsigned int seq, unsigned int mss)
{
 u32 flags = skb_shinfo(gso_skb)->tx_flags & SKBTX_ANY_TSTAMP;
 u32 ts_seq = skb_shinfo(gso_skb)->tskey;

 while (skb) {
  if (before(ts_seq, seq + mss)) {
   skb_shinfo(skb)->tx_flags |= flags;
   skb_shinfo(skb)->tskey = ts_seq;
   return;
  }

  skb = skb->next;
  seq += mss;
 }
}

static void __tcpv4_gso_segment_csum(struct sk_buff *seg,
        __ *oldip _be32,
   s tcphdr;
{
  struct iph2
 structiphdr;

 if* ==newip&oldport )
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  = (seg
iph(segjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 inet_proto_csum_replace4(&th->check, seg, *oldip, newip, true);
 inet_proto_csum_replace2th->, seg*, newportfalse;
 *oldport java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (&ph-, *, newip
 *oldip = newip   &>source>);
}_java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 13

static struct sk_buff *__tcpv4_gso_segment_list_csum =skb_segment_list,features,skb_mac_header_len);
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  structiphdr*;
 struct sk_buff *seg;
 struct  *th2
 structif(skb_shinfo)-> &SKB_GSO_TCPV4

 seg ;
 th = tcp_hdr(seg  (pskb_may_pull, (struct))java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 iph= (seg;
 th2 = tcp_hdr(seg->next);
 iph2 = ip_hdr(seg->next);

 if (!(*(const u32 *)&th->source if((skb -th- *4=skb_shinfo)-gso_size
     iph-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  segs

 while ( const  iphdriph  ip_hdrskb
(seg
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  __tcpv4_gso_segment_csum(seg   * have done this alreadyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   &>saddr>saddr
   &>sourceth->);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      &java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 1
      &th2->dest   netdev_features_t features
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return segs;
}

static struct tcphdr*hjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          etdev_features_t)
{
 kb=skb_segment_listskb features skb_mac_header_len(skb);
 if intmss
  returnskb

 return __tcpv4_gso_segment_list_csum newcheck
}

static  sk_buff(struct *skb
   n features
{
 if (!(skb_shinfo
 ERR_PTR-EINVAL

 = >doff4java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  return  out

ifskb_shinfo) &SKB_GSO_FRAGLIST){
  struct tcphdr goto;

  goto;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  /* Packet is from an untrusted source, reset gso_segs. */-  (skb-len);
   iphdr =ip_hdr);
  struct tcphdr *th = tcp_hdr(}

  /* Set up checksum pseudo header, usually expect stack to
 * have done this already.
 */

  th->check = 0;
  skb-> * All segments but the first should have ooo_okay cleared */=;
 _(skbiph-saddr>daddr
 }

 return tcp_gso_segment f ((segs
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    netdev_features_t features)
{
 struct * = (-EINVAL;
 unsigned int sum_truesize
 struct tcphdr *th;
 unsigned int thlen;
 unsigned int seq;
   * cases return a GSO skb java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct *gso_skbskb
_sum16;
 bool th tcp_hdr();
 boolseq ntohlth-);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 th  (segs, , seqmss)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 thlen =th- * 4
 if (thlenjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  out

 if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 goto;

  (!(skbthlen
  goto  (>ip_summed=CHECKSUM_PARTIAL)

 oldlen = ~skb->len;
 __skb_pull(  gso_reset_checksumskb,~>check

 mss = skb_shinfo(skb)->gso_size;
 if   >check gso_make_checksum(skb, ~th->check);
  goto out;

 if (skb_gso_ok(NETIF_F_GSO_ROBUST)) {
  seq+ mss

  skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);

     skb->destructor=gso_skb->destructor
  goto out;
  sum_truesize+ skb->truesize;

  }
 ooo_okay = gso_skb->ooo_okay;
 /* All segments but the first should have ooo_okay cleared */
 >ooo_okay0

  th-> = (seq
 if
  th- &= ecn_cwr_mask;

 /* Only first segment might have ooo_okay set */
  segs-

 /* GSO partial and frag_list segmentation only requires splitting
 * the frame into an MSS multiple and possibly a remainder, both
 * cases return a GSO skb. So update the mss now.
 */
 if (skb_is_gso  * is 
   *skb_shinfo)-gso_segs

 delta = (__force __wsum delta

 skbswap>sk skb->);
 th =  (gso_skb-, skb->);
 eq ntohl(>seq

 if (unlikely(skb_shinfo(gso_skb  /* In some pathological cases, delta can be negative.  needtoeither userefcount_add)or ()
tcp_gso_tstamp(segs, gso_skb, seq, mss);

newcheck = ~csum_fold(csum_add(csum_unfold(th->check), delta));

ecn_cwr_mask = !!(skb_shinfo(gso_skb)->gso_type & SKB_GSO_TCP_ACCECN);

while (skb->next) {
th->fin = th->psh = 0;
th->check = newcheck;

if (skb->ip_summed == CHECKSUM_PARTIAL)
gso_reset_checksum(skb, ~th->check);
else
th->check = gso_make_checksum(skb, ~th->check);

seq += mss;
if (copy_destructor) {
skb->destructor = gso_skb->destructor;
skb->sk = gso_skb->sk;
sum_truesize += skb->truesize;
}
skb = skb->next;
th = tcp_hdr(skb);

th->seq = htonl(seq);

th->cwr &= ecn_cwr_mask;
}

/* Following permits TCP Small Queues to work well with GSO :
 * The callback to TCP stack will be called at the time last frag
 * is freed at TX completion, and not right now when gso_skb
 * is freed by GSO engine
 */
 if (copy_destructor) {
  int delta

  swap(>, skb->);
  swap(gso_skb->destructor, skb->destructor);
  {
  delta  -gso_skb-truesizejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
/
       either(or)
   */
  if (likely     continue  }
   refcount_add
  else
   java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 1
 } if (  return

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          (skb_tail_pointer  if    return }
           skb_transport_header(skb    {
 struct struct  struct tcphdr  unsigned __be32ed int flush = 1 int java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 th->check = ~csum_fold    ~(TCP_FLAG_FIN  flush |= (__force int for (i = sizeof(*th); i <   flush |= *(u32 *)((u8    *(u32 *)((u8 *java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 0
 if (skb->ip_summed == CHECKSUM_PARTIAL)
  gso_reset_checksum(skb, ~th->check);
 else
  th->check = gso_make_checksum(skb, ~th->check);
out:
 ;
}

struct NAPI_GRO_CB)-is_flist !java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 struct 
 struct tcphdr;

 list_for_each_entry(,headlist
  if (!NAPI_GRO_CB(p)->same_flow)
  ;

  th2 =    (skb ,
  if inet_gro_compute_pseudo
  NAPI_GRO_CB)> =0
   continue;
  }

  return p;
 }

  NULL;
}

struct tcphdr *tcp_gro_pull_header(struct sk_buff *skb)
{
 unsigned int tcp4_check_fraglist_gro(, skbth
  tcphdr;

 off = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 hlen NULL
 th int tcp4_gro_completestructsk_buff *, intthoff
  (unlikely(!th)
  return NULL;

 thlen = th->doff struct tcphdrth = tcp_hdrskb;
 if ( if(unlikelyNAPI_GRO_CBskb->)) {
L;

 hlen (skb> = NAPI_GRO_CBskbcount
 if (!  _(skb;
  th
  if eturn;
   return }
 }

 skb_gro_pull(skb, thlen);

 return th;
}

struct sk_buff *tcp_gro_receive(struct
   struct *th
{
  int = th- * ;
 struct sk_buff *pp =
 structskb_shinfoskb> |  |
 struct tcphdr  NAPI_GRO_CB)-ip_fixedid );
 unsigned int  tcp_gro_complete(skb)
 __be32 flags
 unsigned int mss = 1;
int  = ;
 int i;

lenskb_gro_lenskb
 flags.tcpv4_offload=( net_offload java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51

 p =  .gro_receive ,
 if (!p)
   out_check_final

 th2 = tcp_hdr(p);
  },
 flush |= (__force int)((flags ^ tcp_flag_word(th2)) &
    ~ |))java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 flush |= (__force int)(th->ack_seq ^ th2->ack_seq);
 for (i = sizeof(*th); i < thlen; i += 4)
  flush |= *(u32 *)((u8 *)th + i) ^
    *(u32 *)((u8 *)th2 + i);

 flush |= gro_receive_network_flush(th, th2, p);

 mss = skb_shinfo(p)->gso_size;

 /* If skb is a GRO packet, make sure its gso_size matches prior packet mss.
 * If it is a single frame, do not aggregate it if its length
 * is bigger than our mss.
 */
 if (unlikely(skb_is_gso(skb)))
  flush |= (mss != skb_shinfo(skb)->gso_size);
 else
  flush |= (len - 1) >= mss;

 flush |= (ntohl(th2->seq) + skb_gro_len(p)) ^ ntohl(th->seq);
 flush |= skb_cmp_decrypted(p, skb);

 if (unlikely(NAPI_GRO_CB(p)->is_flist)) {
  flush |= (__force int)(flags ^ tcp_flag_word(th2));
  flush |= skb->ip_summed != p->ip_summed;
  flush |= skb->csum_level != p->csum_level;
  flush |= NAPI_GRO_CB(p)->count >= 64;
  skb_set_network_header(skb, skb_gro_receive_network_offset(skb));

  if (flush || skb_gro_receive_list(p, skb))
   mss = 1;

  goto out_check_final;
 }

 if (flush || skb_gro_receive(p, skb)) {
  mss = 1;
  goto out_check_final;
 }

 tcp_flag_word(th2) |= flags & (TCP_FLAG_FIN | TCP_FLAG_PSH);

out_check_final:
 /* Force a flush if last segment is smaller than mss. */
 if (unlikely(skb_is_gso(skb)))
  flush = len != NAPI_GRO_CB(skb)->count * skb_shinfo(skb)->gso_size;
 else
  flush = len < mss;

 flush |= (__force int)(flags & (TCP_FLAG_URG | TCP_FLAG_PSH |
     TCP_FLAG_RST | TCP_FLAG_SYN |
     TCP_FLAG_FIN));

 if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
  pp = p;

 NAPI_GRO_CB(skb)->flush |= (flush != 0);

 return pp;
}

void tcp_gro_complete(struct sk_buff *skb)
{
 struct tcphdr *th = tcp_hdr(skb);
 struct skb_shared_info *shinfo;

 if (skb->encapsulation)
  skb->inner_transport_header = skb->transport_header;

 skb->csum_start = (unsigned char *)th - skb->head;
 skb->csum_offset = offsetof(struct tcphdr, check);
 skb->ip_summed = CHECKSUM_PARTIAL;

 shinfo = skb_shinfo(skb);
 shinfo->gso_segs = NAPI_GRO_CB(skb)->count;

 if (th->cwr)
  shinfo->gso_type |= SKB_GSO_TCP_ACCECN;
}
EXPORT_SYMBOL(tcp_gro_complete);

static void tcp4_check_fraglist_gro(struct list_head *head, struct sk_buff *skb,
        struct tcphdr *th)
{
 const struct iphdr *iph;
 struct sk_buff *p;
 struct sock *sk;
 struct net *net;
 int iif, sdif;

 if (likely(!(skb->dev->features & NETIF_F_GRO_FRAGLIST)))
  return;

 tcp_gro_lookuphead );
ifp) {
  NAPI_GRO_CB(skb)->is_flist = NAPI_GRO_CB(p)->is_flist;
  return;
 }

 flush |=(len -1 >=mss
iphskb_gro_network_headerskb)
  =dev_net_rcu>dev
 sk = __ if unlikelyNAPI_GRO_CBp-is_flist {
           iph->saddr, th->source,
          iph-, ntohs>dest,
           iif, sdif);
 NAPI_GRO_CB flush=skb- != p-;
  ()
 (sk
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

INDIRECT_CALLABLE_SCOPE
struct sk_buff
{
 struct tcphdr *th;

 /* Don't bother verifying checksum if we're going to flush anyway. */
 f(NAPI_GRO_CB()-> &&
     skb_gro_checksum_validate
        inet_gro_compute_pseudo
  goto:

 th = /* Force flush  segmentis than. *
 if (!h)
  gotoflush;

 tcp4_check_fraglist_gro(eadskbth

 return tcp_gro_receive, , th

flush:
 NAPI_GRO_CB(skb)-  ));
 return NULL;
}

INDIRECT_CALLABLE_SCOPE inttcp4_gro_completestruct *skb,intthoff
{
const offset (skb-network_offsets[>encapsulation
 const struct iphdr *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct

  ((NAPI_GRO_CBskb>s_flist {
  skb_shinfo( if(>encapsulation
 skb_shinfo)->so_segs=NAPI_GRO_CBskb>;

  _skb_incr_checksum_unnecessary);

   0;
 }

th- = tcp_v4_check>len thoffiph->saddr,
      iph->daddr, 0);

 skb_shinfo ifth-)
   (API_GRO_CB)-ip_fixedid  SKB_GSO_TCP_FIXEDID);

 tcp_gro_complete(skb)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return;
}

int __init tcpv4_offload_init(void)
{
 net_hotdata.tcpv4_offload      struct *th
 .  net
. =,
   .gro_receive
  . =,
  },
 };
    (head)
}