cregit-Linux how code gets into the kernel

Release 4.8 net/ipv6/reassembly.c

Directory: net/ipv6
 *      IPv6 fragment reassembly
 *      Linux INET6 implementation
 *      Authors:
 *      Pedro Roque             <>
 *      Based on: net/ipv4/ip_fragment.c
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.

 *      Fixes:
 *      Andi Kleen      Make it work with multiple hosts.
 *                      More RFC compliance.
 *      Horst von Brand Add missing #include <linux/string.h>
 *      Alexey Kuznetsov        SMP races, threading, cleanup.
 *      Patrick McHardy         LRU queue of frag heads for evictor.
 *      Mitsuru KANDA @USAGI    Register inet6_protocol{}.
 *      David Stevens and
 *      YOSHIFUJI,H. @USAGI     Always remove fragment header to
 *                              calculate ICV correctly.

#define pr_fmt(fmt) "IPv6: " fmt

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/jiffies.h>
#include <linux/net.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/in6.h>
#include <linux/ipv6.h>
#include <linux/icmpv6.h>
#include <linux/random.h>
#include <linux/jhash.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/export.h>

#include <net/sock.h>
#include <net/snmp.h>

#include <net/ipv6.h>
#include <net/ip6_route.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
#include <net/rawv6.h>
#include <net/ndisc.h>
#include <net/addrconf.h>
#include <net/inet_frag.h>
#include <net/inet_ecn.h>

static const char ip6_frag_cache_name[] = "ip6-frags";

struct ip6frag_skb_cb {
struct inet6_skb_parm	h;
int			offset;

#define FRAG6_CB(skb)	((struct ip6frag_skb_cb *)((skb)->cb))

static u8 ip6_frag_ecn(const struct ipv6hdr *ipv6h) { return 1 << (ipv6_get_dsfield(ipv6h) & INET_ECN_MASK); }


hannes frederic sowahannes frederic sowa24100.00%1100.00%

static struct inet_frags ip6_frags; static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev, struct net_device *dev); /* * callers should be careful not to use the hash value outside the ipfrag_lock * as doing so could race with ipfrag_hash_rnd being recalculated. */
static unsigned int inet6_hash_frag(__be32 id, const struct in6_addr *saddr, const struct in6_addr *daddr) { net_get_random_once(&ip6_frags.rnd, sizeof(ip6_frags.rnd)); return jhash_3words(ipv6_addr_hash(saddr), ipv6_addr_hash(daddr), (__force u32)id, ip6_frags.rnd); }


hannes frederic sowahannes frederic sowa1829.51%111.11%
eric dumazeteric dumazet914.75%222.22%
jozsef kadlecsikjozsef kadlecsik58.20%111.11%
ilpo jarvinenilpo jarvinen34.92%111.11%
david s. millerdavid s. miller34.92%111.11%
al viroal viro11.64%111.11%
florian westphalflorian westphal11.64%111.11%

static unsigned int ip6_hashfn(const struct inet_frag_queue *q) { const struct frag_queue *fq; fq = container_of(q, struct frag_queue, q); return inet6_hash_frag(fq->id, &fq->saddr, &fq->daddr); }


david s. millerdavid s. miller2142.86%120.00%
pavel emelianovpavel emelianov2040.82%120.00%
yasuyuki kozakaiyasuyuki kozakai510.20%120.00%
florian westphalflorian westphal24.08%120.00%
ilpo jarvinenilpo jarvinen12.04%120.00%

bool ip6_frag_match(const struct inet_frag_queue *q, const void *a) { const struct frag_queue *fq; const struct ip6_create_arg *arg = a; fq = container_of(q, struct frag_queue, q); return fq->id == arg->id && fq->user == arg->user && ipv6_addr_equal(&fq->saddr, arg->src) && ipv6_addr_equal(&fq->daddr, arg->dst) && (arg->iif == fq->iif || !(ipv6_addr_type(arg->dst) & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL))); }


pavel emelianovpavel emelianov7064.22%120.00%
michal kubecekmichal kubecek2623.85%120.00%
patrick mchardypatrick mchardy87.34%120.00%
florian westphalflorian westphal43.67%120.00%
eric dumazeteric dumazet10.92%120.00%

void ip6_frag_init(struct inet_frag_queue *q, const void *a) { struct frag_queue *fq = container_of(q, struct frag_queue, q); const struct ip6_create_arg *arg = a; fq->id = arg->id; fq->user = arg->user; fq->saddr = *arg->src; fq->daddr = *arg->dst; fq->ecn = arg->ecn; }


pavel emelianovpavel emelianov4556.25%225.00%
hannes frederic sowahannes frederic sowa810.00%112.50%
patrick mchardypatrick mchardy810.00%112.50%
alexey dobriyanalexey dobriyan45.00%112.50%
florian westphalflorian westphal22.50%112.50%

void ip6_expire_frag_queue(struct net *net, struct frag_queue *fq, struct inet_frags *frags) { struct net_device *dev = NULL; spin_lock(&fq->q.lock); if (fq->q.flags & INET_FRAG_COMPLETE) goto out; inet_frag_kill(&fq->q, frags); rcu_read_lock(); dev = dev_get_by_index_rcu(net, fq->iif); if (!dev) goto out_rcu_unlock; __IP6_INC_STATS(net, __in6_dev_get(dev), IPSTATS_MIB_REASMFAILS); if (inet_frag_evicting(&fq->q)) goto out_rcu_unlock; __IP6_INC_STATS(net, __in6_dev_get(dev), IPSTATS_MIB_REASMTIMEOUT); /* Don't send error if the first segment did not arrive. */ if (!(fq->q.flags & INET_FRAG_FIRST_IN) || !fq->q.fragments) goto out_rcu_unlock; /* But use as source device on which LAST ARRIVED * segment was received. And do not use fq->dev * pointer directly, device might already disappeared. */ fq->q.fragments->dev = dev; icmpv6_send(fq->q.fragments, ICMPV6_TIME_EXCEED, ICMPV6_EXC_FRAGTIME, 0); out_rcu_unlock: rcu_read_unlock(); out: spin_unlock(&fq->q.lock); inet_frag_put(&fq->q, frags); }


hideaki yoshifujihideaki yoshifuji2814.29%15.56%
americo wangamerico wang2412.24%15.56%
nikolay aleksandrovnikolay aleksandrov189.18%316.67%
pavel emelianovpavel emelianov147.14%15.56%
eric dumazeteric dumazet136.63%211.11%
ingo oeseringo oeser136.63%15.56%
daniel lezcanodaniel lezcano94.59%15.56%
denis v. lunevdenis v. lunev42.04%15.56%
joe perchesjoe perches21.02%15.56%
eric w. biedermaneric w. biederman10.51%15.56%

static void ip6_frag_expire(unsigned long data) { struct frag_queue *fq; struct net *net; fq = container_of((struct inet_frag_queue *)data, struct frag_queue, q); net = container_of(fq->, struct net, ipv6.frags); ip6_expire_frag_queue(net, fq, &ip6_frags); }


americo wangamerico wang6295.38%150.00%

static struct frag_queue * fq_find(struct net *net, __be32 id, const struct in6_addr *src, const struct in6_addr *dst, int iif, u8 ecn) { struct inet_frag_queue *q; struct ip6_create_arg arg; unsigned int hash; = id; arg.user = IP6_DEFRAG_LOCAL_DELIVER; arg.src = src; arg.dst = dst; arg.iif = iif; arg.ecn = ecn; hash = inet6_hash_frag(id, src, dst); q = inet_frag_find(&net->ipv6.frags, &ip6_frags, &arg, hash); if (IS_ERR_OR_NULL(q)) { inet_frag_maybe_warn_overflow(q, pr_fmt()); return NULL; } return container_of(q, struct frag_queue, q); }


pavel emelianovpavel emelianov5437.24%430.77%
fabian frederickfabian frederick4128.28%17.69%
hannes frederic sowahannes frederic sowa1812.41%215.38%
michal kubecekmichal kubecek96.21%17.69%
patrick mchardypatrick mchardy53.45%17.69%
shan weishan wei32.07%17.69%
ilpo jarvinenilpo jarvinen10.69%17.69%

static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb, struct frag_hdr *fhdr, int nhoff) { struct sk_buff *prev, *next; struct net_device *dev; int offset, end; struct net *net = dev_net(skb_dst(skb)->dev); u8 ecn; if (fq->q.flags & INET_FRAG_COMPLETE) goto err; offset = ntohs(fhdr->frag_off) & ~0x7; end = offset + (ntohs(ipv6_hdr(skb)->payload_len) - ((u8 *)(fhdr + 1) - (u8 *)(ipv6_hdr(skb) + 1))); if ((unsigned int)end > IPV6_MAXPLEN) { __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS); icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, ((u8 *)&fhdr->frag_off - skb_network_header(skb))); return -1; } ecn = ip6_frag_ecn(ipv6_hdr(skb)); if (skb->ip_summed == CHECKSUM_COMPLETE) { const unsigned char *nh = skb_network_header(skb); skb->csum = csum_sub(skb->csum, csum_partial(nh, (u8 *)(fhdr + 1) - nh, 0)); } /* Is this the final fragment? */ if (!(fhdr->frag_off & htons(IP6_MF))) { /* If we already have some bits beyond end * or have different end, the segment is corrupted. */ if (end < fq->q.len || ((fq->q.flags & INET_FRAG_LAST_IN) && end != fq->q.len)) goto err; fq->q.flags |= INET_FRAG_LAST_IN; fq->q.len = end; } else { /* Check if the fragment is rounded to 8 bytes. * Required by the RFC. */ if (end & 0x7) { /* RFC2460 says always send parameter problem in * this case. -DaveM */ __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS); icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, offsetof(struct ipv6hdr, payload_len)); return -1; } if (end > fq->q.len) { /* Some bits beyond end -> corruption. */ if (fq->q.flags & INET_FRAG_LAST_IN) goto err; fq->q.len = end; } } if (end == offset) goto err; /* Point into the IP datagram 'data' part. */ if (!pskb_pull(skb, (u8 *) (fhdr + 1) - skb->data)) goto err; if (pskb_trim_rcsum(skb, end - offset)) goto err; /* Find out which fragments are in front and at the back of us * in the chain of fragments so far. We must know where to put * this fragment, right? */ prev = fq->q.fragments_tail; if (!prev || FRAG6_CB(prev)->offset < offset) { next = NULL; goto found; } prev = NULL; for (next = fq->q.fragments; next != NULL; next = next->next) { if (FRAG6_CB(next)->offset >= offset) break; /* bingo! */ prev = next; } found: /* RFC5722, Section 4, amended by Errata ID : 3089 * When reassembling an IPv6 datagram, if * one or more its constituent fragments is determined to be an * overlapping fragment, the entire datagram (and any constituent * fragments) MUST be silently discarded. */ /* Check for overlap with preceding fragment. */ if (prev && (FRAG6_CB(prev)->offset + prev->len) > offset) goto discard_fq; /* Look for overlap with succeeding segment. */ if (next && FRAG6_CB(next)->offset < end) goto discard_fq; FRAG6_CB(skb)->offset = offset; /* Insert this fragment in the chain of fragments. */ skb->next = next; if (!next) fq->q.fragments_tail = skb; if (prev) prev->next = skb; else fq->q.fragments = skb; dev = skb->dev; if (dev) { fq->iif = dev->ifindex; skb->dev = NULL; } fq->q.stamp = skb->tstamp; fq->q.meat += skb->len; fq->ecn |= ecn; add_frag_mem_limit(fq->, skb->truesize); /* The first fragment. * nhoffset is obtained from the first fragment, of course. */ if (offset == 0) { fq->nhoffset = nhoff; fq->q.flags |= INET_FRAG_FIRST_IN; } if (fq->q.flags == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) && fq->q.meat == fq->q.len) { int res; unsigned long orefdst = skb->_skb_refdst; skb->_skb_refdst = 0UL; res = ip6_frag_reasm(fq, prev, dev); skb->_skb_refdst = orefdst; return res; } skb_dst_drop(skb); return -1; discard_fq: inet_frag_kill(&fq->q, &ip6_frags); err: __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMFAILS); kfree_skb(skb); return -1; }


linus torvaldslinus torvalds809.94%25.26%
herbert xuherbert xu566.96%12.63%
eric dumazeteric dumazet556.83%513.16%
changli gaochangli gao465.71%12.63%
pavel emelianovpavel emelianov384.72%25.26%
arnaldo carvalho de meloarnaldo carvalho de melo242.98%25.26%
hideaki yoshifujihideaki yoshifuji222.73%513.16%
hannes frederic sowahannes frederic sowa192.36%12.63%
denis v. lunevdenis v. lunev182.24%25.26%
nicolas dichtelnicolas dichtel111.37%12.63%
shirley mashirley ma91.12%12.63%
americo wangamerico wang70.87%12.63%
joe perchesjoe perches70.87%12.63%
nikolay aleksandrovnikolay aleksandrov60.75%12.63%
jesper dangaard brouerjesper dangaard brouer40.50%12.63%
florian westphalflorian westphal20.25%12.63%
patrick mchardypatrick mchardy20.25%25.26%
stephen hemmingerstephen hemminger10.12%12.63%
shan weishan wei10.12%12.63%
fabian frederickfabian frederick10.12%12.63%

/* * Check if this packet is complete. * Returns NULL on failure by any reason, and pointer * to current nexthdr field in reassembled frame. * * It is called with locked fq, and caller must check that * queue is eligible for reassembly i.e. it is not COMPLETE, * the last and the first frames arrived and all the bits are here. */
static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev, struct net_device *dev) { struct net *net = container_of(fq->, struct net, ipv6.frags); struct sk_buff *fp, *head = fq->q.fragments; int payload_len; unsigned int nhoff; int sum_truesize; u8 ecn; inet_frag_kill(&fq->q, &ip6_frags); ecn = ip_frag_ecn_table[fq->ecn]; if (unlikely(ecn == 0xff)) goto out_fail; /* Make the one we just received the head. */ if (prev) { head = prev->next; fp = skb_clone(head, GFP_ATOMIC); if (!fp) goto out_oom; fp->next = head->next; if (!fp->next) fq->q.fragments_tail = fp; prev->next = fp; skb_morph(head, fq->q.fragments); head->next = fq->q.fragments->next; consume_skb(fq->q.fragments); fq->q.fragments = head; } WARN_ON(head == NULL); WARN_ON(FRAG6_CB(head)->offset != 0); /* Unfragmented part is taken from the first segment. */ payload_len = ((head->data - skb_network_header(head)) - sizeof(struct ipv6hdr) + fq->q.len - sizeof(struct frag_hdr)); if (payload_len > IPV6_MAXPLEN) goto out_oversize; /* Head of list must not be cloned. */ if (skb_unclone(head, GFP_ATOMIC)) goto out_oom; /* If the first fragment is fragmented itself, we split * it to two chunks: the first with data and paged part * and the second, holding only fragments. */ if (skb_has_frag_list(head)) { struct sk_buff *clone; int i, plen = 0; clone = alloc_skb(0, GFP_ATOMIC); if (!clone) goto out_oom; clone->next = head->next; head->next = clone; skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list; skb_frag_list_init(head); for (i = 0; i < skb_shinfo(head)->nr_frags; i++) plen += skb_frag_size(&skb_shinfo(head)->frags[i]); clone->len = clone->data_len = head->data_len - plen; head->data_len -= clone->len; head->len -= clone->len; clone->csum = 0; clone->ip_summed = head->ip_summed; add_frag_mem_limit(fq->, clone->truesize); } /* We have to remove fragment header from datagram and to relocate * header in order to calculate ICV correctly. */ nhoff = fq->nhoffset; skb_network_header(head)[nhoff] = skb_transport_header(head)[0]; memmove(head->head + sizeof(struct frag_hdr), head->head, (head->data - head->head) - sizeof(struct frag_hdr)); head->mac_header += sizeof(struct frag_hdr); head->network_header += sizeof(struct frag_hdr); skb_reset_transport_header(head); skb_push(head, head->data - skb_network_header(head)); sum_truesize = head->truesize; for (fp = head->next; fp;) { bool headstolen; int delta; struct sk_buff *next = fp->next; sum_truesize += fp->truesize; if (head->ip_summed != fp->ip_summed) head->ip_summed = CHECKSUM_NONE; else if (head->ip_summed == CHECKSUM_COMPLETE) head->csum = csum_add(head->csum, fp->csum); if (skb_try_coalesce(head, fp, &headstolen, &delta)) { kfree_skb_partial(fp, headstolen); } else { if (!skb_shinfo(head)->frag_list) skb_shinfo(head)->frag_list = fp; head->data_len += fp->len; head->len += fp->len; head->truesize += fp->truesize; } fp = next; } sub_frag_mem_limit(fq->, sum_truesize); head->next = NULL; head->dev = dev; head->tstamp = fq->q.stamp; ipv6_hdr(head)->payload_len = htons(payload_len); ipv6_change_dsfield(ipv6_hdr(head), 0xff, ecn); IP6CB(head)->nhoff = nhoff; IP6CB(head)->flags |= IP6SKB_FRAGMENTED; /* Yes, and fold redundant checksum back. 8) */ skb_postpush_rcsum(head, skb_network_header(head), skb_network_header_len(head)); rcu_read_lock(); __IP6_INC_STATS(net, __in6_dev_get(dev), IPSTATS_MIB_REASMOKS); rcu_read_unlock(); fq->q.fragments = NULL; fq->q.fragments_tail = NULL; return 1; out_oversize: net_dbg_ratelimited("ip6_frag_reasm: payload len = %d\n", payload_len); goto out_fail; out_oom: net_dbg_ratelimited("ip6_frag_reasm: no memory for reassembly\n"); out_fail: rcu_read_lock(); __IP6_INC_STATS(net, __in6_dev_get(dev), IPSTATS_MIB_REASMFAILS); rcu_read_unlock(); return -1; }


linus torvaldslinus torvalds28332.98%12.27%
eric dumazeteric dumazet10111.77%613.64%
herbert xuherbert xu768.86%12.27%
hideaki yoshifujihideaki yoshifuji556.41%613.64%
hannes frederic sowahannes frederic sowa455.24%24.55%
arnaldo carvalho de meloarnaldo carvalho de melo283.26%511.36%
jorge boncomptejorge boncompte232.68%12.27%
pavel emelianovpavel emelianov232.68%24.55%
changli gaochangli gao232.68%12.27%
patrick mchardypatrick mchardy101.17%24.55%
jesper dangaard brouerjesper dangaard brouer70.82%12.27%
americo wangamerico wang70.82%12.27%
ian morrisian morris50.58%24.55%
florian westphalflorian westphal40.47%12.27%
ilpo jarvinenilpo jarvinen40.47%12.27%
daniel borkmanndaniel borkmann30.35%12.27%
denis v. lunevdenis v. lunev20.23%12.27%
david s. millerdavid s. miller20.23%24.55%
joe perchesjoe perches20.23%12.27%
yasuyuki kozakaiyasuyuki kozakai10.12%12.27%
pravin b shelarpravin b shelar10.12%12.27%

static int ipv6_frag_rcv(struct sk_buff *skb) { struct frag_hdr *fhdr; struct frag_queue *fq; const struct ipv6hdr *hdr = ipv6_hdr(skb); struct net *net = dev_net(skb_dst(skb)->dev); if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED) goto fail_hdr; __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMREQDS); /* Jumbo payload inhibits frag. header */ if (hdr->payload_len == 0) goto fail_hdr; if (!pskb_may_pull(skb, (skb_transport_offset(skb) + sizeof(struct frag_hdr)))) goto fail_hdr; hdr = ipv6_hdr(skb); fhdr = (struct frag_hdr *)skb_transport_header(skb); if (!(fhdr->frag_off & htons(0xFFF9))) { /* It is not a fragmented frame */ skb->transport_header += sizeof(struct frag_hdr); __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMOKS); IP6CB(skb)->nhoff = (u8 *)fhdr - skb_network_header(skb); IP6CB(skb)->flags |= IP6SKB_FRAGMENTED; return 1; } fq = fq_find(net, fhdr->identification, &hdr->saddr, &hdr->daddr, skb->dev ? skb->dev->ifindex : 0, ip6_frag_ecn(hdr)); if (fq) { int ret; spin_lock(&fq->q.lock); ret = ip6_frag_queue(fq, skb, fhdr, IP6CB(skb)->nhoff); spin_unlock(&fq->q.lock); inet_frag_put(&fq->q, &ip6_frags); return ret; } __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_REASMFAILS); kfree_skb(skb); return -1; fail_hdr: __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS); icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, skb_network_header_len(skb)); return -1; }


denis v. lunevdenis v. lunev4813.37%39.68%
linus torvaldslinus torvalds3810.58%13.23%
hannes frederic sowahannes frederic sowa287.80%26.45%
hideaki yoshifujihideaki yoshifuji267.24%412.90%
eric dumazeteric dumazet205.57%39.68%
arnaldo carvalho de meloarnaldo carvalho de melo195.29%516.13%
michal kubecekmichal kubecek123.34%13.23%
patrick mchardypatrick mchardy123.34%13.23%
pavel emelianovpavel emelianov113.06%26.45%
americo wangamerico wang71.95%13.23%
shan weishan wei41.11%13.23%
herbert xuherbert xu30.84%26.45%
mitsuru kandamitsuru kanda20.56%13.23%

static const struct inet6_protocol frag_protocol = { .handler = ipv6_frag_rcv, .flags = INET6_PROTO_NOPOLICY, }; #ifdef CONFIG_SYSCTL static int zero; static struct ctl_table ip6_frags_ns_ctl_table[] = { { .procname = "ip6frag_high_thresh", .data = &init_net.ipv6.