source: src/linux/universal/linux-3.18/net/core/skbuff.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 2 months ago

update

File size: 108.1 KB
Line 
1/*
2 *      Routines having to do with the 'struct sk_buff' memory handlers.
3 *
4 *      Authors:        Alan Cox <alan@lxorguk.ukuu.org.uk>
5 *                      Florian La Roche <rzsfl@rz.uni-sb.de>
6 *
7 *      Fixes:
8 *              Alan Cox        :       Fixed the worst of the load
9 *                                      balancer bugs.
10 *              Dave Platt      :       Interrupt stacking fix.
11 *      Richard Kooijman        :       Timestamp fixes.
12 *              Alan Cox        :       Changed buffer format.
13 *              Alan Cox        :       destructor hook for AF_UNIX etc.
14 *              Linus Torvalds  :       Better skb_clone.
15 *              Alan Cox        :       Added skb_copy.
16 *              Alan Cox        :       Added all the changed routines Linus
17 *                                      only put in the headers
18 *              Ray VanTassle   :       Fixed --skb->lock in free
19 *              Alan Cox        :       skb_copy copy arp field
20 *              Andi Kleen      :       slabified it.
21 *              Robert Olsson   :       Removed skb_head_pool
22 *
23 *      NOTE:
24 *              The __skb_ routines should be called with interrupts
25 *      disabled, or you better be *real* sure that the operation is atomic
26 *      with respect to whatever list is being frobbed (e.g. via lock_sock()
27 *      or via disabling bottom half handlers, etc).
28 *
29 *      This program is free software; you can redistribute it and/or
30 *      modify it under the terms of the GNU General Public License
31 *      as published by the Free Software Foundation; either version
32 *      2 of the License, or (at your option) any later version.
33 */
34
35/*
36 *      The functions in this file will not compile correctly with gcc 2.4.x
37 */
38
39#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40
41#include <linux/module.h>
42#include <linux/types.h>
43#include <linux/kernel.h>
44#include <linux/kmemcheck.h>
45#include <linux/mm.h>
46#include <linux/interrupt.h>
47#include <linux/in.h>
48#include <linux/inet.h>
49#include <linux/slab.h>
50#include <linux/tcp.h>
51#include <linux/udp.h>
52#include <linux/netdevice.h>
53#ifdef CONFIG_NET_CLS_ACT
54#include <net/pkt_sched.h>
55#endif
56#include <linux/string.h>
57#include <linux/skbuff.h>
58#include <linux/splice.h>
59#include <linux/cache.h>
60#include <linux/rtnetlink.h>
61#include <linux/init.h>
62#include <linux/scatterlist.h>
63#include <linux/errqueue.h>
64#include <linux/prefetch.h>
65#include <linux/if.h>
66#include <linux/if_vlan.h>
67
68#include <net/protocol.h>
69#include <net/dst.h>
70#include <net/sock.h>
71#include <net/checksum.h>
72#include <net/ip6_checksum.h>
73#include <net/xfrm.h>
74
75#include <asm/uaccess.h>
76#include <trace/events/skb.h>
77#include <linux/highmem.h>
78
79
80#define BCMFASTPATH
81#define BCMFASTPATH_HOST
82
83struct kmem_cache *skbuff_head_cache __read_mostly;
84static struct kmem_cache *skbuff_fclone_cache __read_mostly;
85int sysctl_max_skb_frags __read_mostly = MAX_SKB_FRAGS;
86EXPORT_SYMBOL(sysctl_max_skb_frags);
87#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
88static struct kmem_cache *skbuff_cb_store_cache __read_mostly;
89#endif
90
91#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
92/* Control buffer save/restore for IMQ devices */
93struct skb_cb_table {
94        char                    cb[48] __aligned(8);
95        void                    *cb_next;
96        atomic_t                refcnt;
97};
98
99static DEFINE_SPINLOCK(skb_cb_store_lock);
100
101int skb_save_cb(struct sk_buff *skb)
102{
103        struct skb_cb_table *next;
104
105        next = kmem_cache_alloc(skbuff_cb_store_cache, GFP_ATOMIC);
106        if (!next)
107                return -ENOMEM;
108
109        BUILD_BUG_ON(sizeof(skb->cb) != sizeof(next->cb));
110
111        memcpy(next->cb, skb->cb, sizeof(skb->cb));
112        next->cb_next = skb->cb_next;
113
114        atomic_set(&next->refcnt, 1);
115
116        skb->cb_next = next;
117        return 0;
118}
119EXPORT_SYMBOL(skb_save_cb);
120
121int skb_restore_cb(struct sk_buff *skb)
122{
123        struct skb_cb_table *next;
124
125        if (!skb->cb_next)
126                return 0;
127
128        next = skb->cb_next;
129
130        BUILD_BUG_ON(sizeof(skb->cb) != sizeof(next->cb));
131
132        memcpy(skb->cb, next->cb, sizeof(skb->cb));
133        skb->cb_next = next->cb_next;
134
135        spin_lock(&skb_cb_store_lock);
136
137        if (atomic_dec_and_test(&next->refcnt))
138                kmem_cache_free(skbuff_cb_store_cache, next);
139
140        spin_unlock(&skb_cb_store_lock);
141
142        return 0;
143}
144EXPORT_SYMBOL(skb_restore_cb);
145
146#endif
147
148/**
149 *      skb_panic - private function for out-of-line support
150 *      @skb:   buffer
151 *      @sz:    size
152 *      @addr:  address
153 *      @msg:   skb_over_panic or skb_under_panic
154 *
155 *      Out-of-line support for skb_put() and skb_push().
156 *      Called via the wrapper skb_over_panic() or skb_under_panic().
157 *      Keep out of line to prevent kernel bloat.
158 *      __builtin_return_address is not used because it is not always reliable.
159 */
160static void skb_panic(struct sk_buff *skb, unsigned int sz, void *addr,
161                      const char msg[])
162{
163        pr_emerg("%s: text:%p len:%d put:%d head:%p data:%p tail:%#lx end:%#lx dev:%s\n",
164                 msg, addr, skb->len, sz, skb->head, skb->data,
165                 (unsigned long)skb->tail, (unsigned long)skb->end,
166                 skb->dev ? skb->dev->name : "<NULL>");
167        BUG();
168}
169
170static void skb_over_panic(struct sk_buff *skb, unsigned int sz, void *addr)
171{
172        skb_panic(skb, sz, addr, __func__);
173}
174
175static void skb_under_panic(struct sk_buff *skb, unsigned int sz, void *addr)
176{
177        skb_panic(skb, sz, addr, __func__);
178}
179
180/*
181 * kmalloc_reserve is a wrapper around kmalloc_node_track_caller that tells
182 * the caller if emergency pfmemalloc reserves are being used. If it is and
183 * the socket is later found to be SOCK_MEMALLOC then PFMEMALLOC reserves
184 * may be used. Otherwise, the packet data may be discarded until enough
185 * memory is free
186 */
187#define kmalloc_reserve(size, gfp, node, pfmemalloc) \
188         __kmalloc_reserve(size, gfp, node, _RET_IP_, pfmemalloc)
189
190static void *__kmalloc_reserve(size_t size, gfp_t flags, int node,
191                               unsigned long ip, bool *pfmemalloc)
192{
193        void *obj;
194        bool ret_pfmemalloc = false;
195
196        /*
197         * Try a regular allocation, when that fails and we're not entitled
198         * to the reserves, fail.
199         */
200        obj = kmalloc_node_track_caller(size,
201                                        flags | __GFP_NOMEMALLOC | __GFP_NOWARN,
202                                        node);
203        if (obj || !(gfp_pfmemalloc_allowed(flags)))
204                goto out;
205
206        /* Try again but now we are using pfmemalloc reserves */
207        ret_pfmemalloc = true;
208        obj = kmalloc_node_track_caller(size, flags, node);
209
210out:
211        if (pfmemalloc)
212                *pfmemalloc = ret_pfmemalloc;
213
214        return obj;
215}
216
217/*      Allocate a new skbuff. We do this ourselves so we can fill in a few
218 *      'private' fields and also do memory statistics to find all the
219 *      [BEEP] leaks.
220 *
221 */
222
223struct sk_buff *__alloc_skb_head(gfp_t gfp_mask, int node)
224{
225        struct sk_buff *skb;
226
227        /* Get the HEAD */
228        skb = kmem_cache_alloc_node(skbuff_head_cache,
229                                    gfp_mask & ~__GFP_DMA, node);
230        if (!skb)
231                goto out;
232
233        /*
234         * Only clear those fields we need to clear, not those that we will
235         * actually initialise below. Hence, don't put any more fields after
236         * the tail pointer in struct sk_buff!
237         */
238        memset(skb, 0, offsetof(struct sk_buff, tail));
239        skb->head = NULL;
240        skb->truesize = sizeof(struct sk_buff);
241        atomic_set(&skb->users, 1);
242
243        skb->mac_header = (typeof(skb->mac_header))~0U;
244out:
245        return skb;
246}
247
248/**
249 *      __alloc_skb     -       allocate a network buffer
250 *      @size: size to allocate
251 *      @gfp_mask: allocation mask
252 *      @flags: If SKB_ALLOC_FCLONE is set, allocate from fclone cache
253 *              instead of head cache and allocate a cloned (child) skb.
254 *              If SKB_ALLOC_RX is set, __GFP_MEMALLOC will be used for
255 *              allocations in case the data is required for writeback
256 *      @node: numa node to allocate memory on
257 *
258 *      Allocate a new &sk_buff. The returned buffer has no headroom and a
259 *      tail room of at least size bytes. The object has a reference count
260 *      of one. The return is the buffer. On a failure the return is %NULL.
261 *
262 *      Buffers may only be allocated from interrupts using a @gfp_mask of
263 *      %GFP_ATOMIC.
264 */
265struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
266                            int flags, int node)
267{
268        struct kmem_cache *cache;
269        struct skb_shared_info *shinfo;
270        struct sk_buff *skb;
271        u8 *data;
272        bool pfmemalloc;
273
274        cache = (flags & SKB_ALLOC_FCLONE)
275                ? skbuff_fclone_cache : skbuff_head_cache;
276
277        if (sk_memalloc_socks() && (flags & SKB_ALLOC_RX))
278                gfp_mask |= __GFP_MEMALLOC;
279
280#ifdef CONFIG_ARCH_IXP4XX
281        gfp_mask |= GFP_DMA;
282#endif
283
284        /* Get the HEAD */
285        skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);
286        if (!skb)
287                goto out;
288        prefetchw(skb);
289
290
291        /* We do our best to align skb_shared_info on a separate cache
292         * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives
293         * aligned memory blocks, unless SLUB/SLAB debug is enabled.
294         * Both skb->head and skb_shared_info are cache line aligned.
295         */
296        size = SKB_DATA_ALIGN(size);
297        size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
298        data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc);
299        if (!data)
300                goto nodata;
301        /* kmalloc(size) might give us more room than requested.
302         * Put skb_shared_info exactly at the end of allocated zone,
303         * to allow max possible filling before reallocation.
304         */
305        size = SKB_WITH_OVERHEAD(ksize(data));
306        prefetchw(data + size);
307
308        /*
309         * Only clear those fields we need to clear, not those that we will
310         * actually initialise below. Hence, don't put any more fields after
311         * the tail pointer in struct sk_buff!
312         */
313        memset(skb, 0, offsetof(struct sk_buff, tail));
314        /* Account for allocated memory : skb + skb->head */
315        skb->truesize = SKB_TRUESIZE(size);
316        skb->pfmemalloc = pfmemalloc;
317        atomic_set(&skb->users, 1);
318        skb->head = data;
319        skb->data = data;
320        skb_reset_tail_pointer(skb);
321        skb->end = skb->tail + size;
322        skb->mac_header = (typeof(skb->mac_header))~0U;
323        skb->transport_header = (typeof(skb->transport_header))~0U;
324#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
325        skb->cb_next = NULL;
326        skb->nf_queue_entry = NULL;
327        skb->imq_flags = 0;
328#endif
329
330        /* make sure we initialize shinfo sequentially */
331        shinfo = skb_shinfo(skb);
332        memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
333        atomic_set(&shinfo->dataref, 1);
334        kmemcheck_annotate_variable(shinfo->destructor_arg);
335
336        if (flags & SKB_ALLOC_FCLONE) {
337                struct sk_buff_fclones *fclones;
338
339                fclones = container_of(skb, struct sk_buff_fclones, skb1);
340
341                kmemcheck_annotate_bitfield(&fclones->skb2, flags1);
342                skb->fclone = SKB_FCLONE_ORIG;
343                atomic_set(&fclones->fclone_ref, 1);
344
345                fclones->skb2.fclone = SKB_FCLONE_FREE;
346                fclones->skb2.pfmemalloc = pfmemalloc;
347        }
348out:
349        return skb;
350nodata:
351        kmem_cache_free(cache, skb);
352        skb = NULL;
353        goto out;
354}
355EXPORT_SYMBOL(__alloc_skb);
356
357/**
358 * __build_skb - build a network buffer
359 * @data: data buffer provided by caller
360 * @frag_size: size of data, or 0 if head was kmalloced
361 *
362 * Allocate a new &sk_buff. Caller provides space holding head and
363 * skb_shared_info. @data must have been allocated by kmalloc() only if
364 * @frag_size is 0, otherwise data should come from the page allocator
365 *  or vmalloc()
366 * The return is the new skb buffer.
367 * On a failure the return is %NULL, and @data is not freed.
368 * Notes :
369 *  Before IO, driver allocates only data buffer where NIC put incoming frame
370 *  Driver should add room at head (NET_SKB_PAD) and
371 *  MUST add room at tail (SKB_DATA_ALIGN(skb_shared_info))
372 *  After IO, driver calls build_skb(), to allocate sk_buff and populate it
373 *  before giving packet to stack.
374 *  RX rings only contains data buffers, not full skbs.
375 */
376struct sk_buff *__build_skb(void *data, unsigned int frag_size)
377{
378        struct skb_shared_info *shinfo;
379        struct sk_buff *skb;
380        unsigned int size = frag_size ? : ksize(data);
381
382        skb = kmem_cache_alloc(skbuff_head_cache, GFP_ATOMIC);
383        if (!skb)
384                return NULL;
385
386        size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
387
388        memset(skb, 0, offsetof(struct sk_buff, tail));
389        skb->truesize = SKB_TRUESIZE(size);
390        atomic_set(&skb->users, 1);
391        skb->head = data;
392        skb->data = data;
393        skb_reset_tail_pointer(skb);
394        skb->end = skb->tail + size;
395        skb->mac_header = (typeof(skb->mac_header))~0U;
396        skb->transport_header = (typeof(skb->transport_header))~0U;
397
398        /* make sure we initialize shinfo sequentially */
399        shinfo = skb_shinfo(skb);
400        memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
401        atomic_set(&shinfo->dataref, 1);
402        kmemcheck_annotate_variable(shinfo->destructor_arg);
403
404        return skb;
405}
406
407/* build_skb() is wrapper over __build_skb(), that specifically
408 * takes care of skb->head and skb->pfmemalloc
409 * This means that if @frag_size is not zero, then @data must be backed
410 * by a page fragment, not kmalloc() or vmalloc()
411 */
412struct sk_buff *build_skb(void *data, unsigned int frag_size)
413{
414        struct sk_buff *skb = __build_skb(data, frag_size);
415
416        if (skb && frag_size) {
417                skb->head_frag = 1;
418                if (virt_to_head_page(data)->pfmemalloc)
419                        skb->pfmemalloc = 1;
420        }
421        return skb;
422}
423EXPORT_SYMBOL(build_skb);
424
425struct netdev_alloc_cache {
426        struct page_frag        frag;
427        /* we maintain a pagecount bias, so that we dont dirty cache line
428         * containing page->_count every time we allocate a fragment.
429         */
430        unsigned int            pagecnt_bias;
431};
432static DEFINE_PER_CPU(struct netdev_alloc_cache, netdev_alloc_cache);
433
434static void *__netdev_alloc_frag(unsigned int fragsz, gfp_t gfp_mask)
435{
436        struct netdev_alloc_cache *nc;
437        void *data = NULL;
438        int order;
439        unsigned long flags;
440
441        local_irq_save(flags);
442        nc = this_cpu_ptr(&netdev_alloc_cache);
443        if (unlikely(!nc->frag.page)) {
444refill:
445                for (order = NETDEV_FRAG_PAGE_MAX_ORDER; ;) {
446                        gfp_t gfp = gfp_mask;
447
448                        if (order)
449                                gfp |= __GFP_COMP | __GFP_NOWARN |
450                                       __GFP_NOMEMALLOC;
451                        nc->frag.page = alloc_pages(gfp, order);
452                        if (likely(nc->frag.page))
453                                break;
454                        if (--order < 0)
455                                goto end;
456                }
457                nc->frag.size = PAGE_SIZE << order;
458                /* Even if we own the page, we do not use atomic_set().
459                 * This would break get_page_unless_zero() users.
460                 */
461                atomic_add(NETDEV_PAGECNT_MAX_BIAS - 1,
462                           &nc->frag.page->_count);
463                nc->pagecnt_bias = NETDEV_PAGECNT_MAX_BIAS;
464                nc->frag.offset = 0;
465        }
466
467        if (nc->frag.offset + fragsz > nc->frag.size) {
468                if (atomic_read(&nc->frag.page->_count) != nc->pagecnt_bias) {
469                        if (!atomic_sub_and_test(nc->pagecnt_bias,
470                                                 &nc->frag.page->_count))
471                                goto refill;
472                        /* OK, page count is 0, we can safely set it */
473                        atomic_set(&nc->frag.page->_count,
474                                   NETDEV_PAGECNT_MAX_BIAS);
475                } else {
476                        atomic_add(NETDEV_PAGECNT_MAX_BIAS - nc->pagecnt_bias,
477                                   &nc->frag.page->_count);
478                }
479                nc->pagecnt_bias = NETDEV_PAGECNT_MAX_BIAS;
480                nc->frag.offset = 0;
481        }
482
483        data = page_address(nc->frag.page) + nc->frag.offset;
484        nc->frag.offset += fragsz;
485        nc->pagecnt_bias--;
486end:
487        local_irq_restore(flags);
488        return data;
489}
490
491/**
492 * netdev_alloc_frag - allocate a page fragment
493 * @fragsz: fragment size
494 *
495 * Allocates a frag from a page for receive buffer.
496 * Uses GFP_ATOMIC allocations.
497 */
498void *netdev_alloc_frag(unsigned int fragsz)
499{
500        return __netdev_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD);
501}
502EXPORT_SYMBOL(netdev_alloc_frag);
503
504/**
505 *      __netdev_alloc_skb - allocate an skbuff for rx on a specific device
506 *      @dev: network device to receive on
507 *      @length: length to allocate
508 *      @gfp_mask: get_free_pages mask, passed to alloc_skb
509 *
510 *      Allocate a new &sk_buff and assign it a usage count of one. The
511 *      buffer has unspecified headroom built in. Users should allocate
512 *      the headroom they think they need without accounting for the
513 *      built in space. The built in space is used for optimisations.
514 *
515 *      %NULL is returned if there is no free memory.
516 */
517struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
518                                   unsigned int length, gfp_t gfp_mask)
519{
520        struct sk_buff *skb = NULL;
521        unsigned int fragsz = SKB_DATA_ALIGN(length + NET_SKB_PAD) +
522                              SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
523
524
525#ifdef CONFIG_ARCH_IXP4XX
526        gfp_mask |= GFP_DMA;
527#endif
528
529        if (fragsz <= PAGE_SIZE && !(gfp_mask & (__GFP_WAIT | GFP_DMA))) {
530                void *data;
531
532                if (sk_memalloc_socks())
533                        gfp_mask |= __GFP_MEMALLOC;
534
535                data = __netdev_alloc_frag(fragsz, gfp_mask);
536                if (likely(data)) {
537                        skb = build_skb(data, fragsz);
538                        if (unlikely(!skb))
539                                put_page(virt_to_head_page(data));
540                }
541        } else {
542                skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask,
543                                  SKB_ALLOC_RX, NUMA_NO_NODE);
544        }
545        if (likely(skb)) {
546                skb_reserve(skb, NET_SKB_PAD);
547                skb->dev = dev;
548        }
549        return skb;
550}
551EXPORT_SYMBOL(__netdev_alloc_skb);
552
553struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
554                unsigned int length, gfp_t gfp)
555{
556        struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
557
558#ifdef CONFIG_ETHERNET_PACKET_MANGLE
559        if (dev->priv_flags & IFF_NO_IP_ALIGN)
560                return skb;
561#endif
562
563        if (NET_IP_ALIGN && skb)
564                skb_reserve(skb, NET_IP_ALIGN);
565        return skb;
566}
567EXPORT_SYMBOL(__netdev_alloc_skb_ip_align);
568
569void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
570                     int size, unsigned int truesize)
571{
572        skb_fill_page_desc(skb, i, page, off, size);
573        skb->len += size;
574        skb->data_len += size;
575        skb->truesize += truesize;
576}
577EXPORT_SYMBOL(skb_add_rx_frag);
578
579void skb_coalesce_rx_frag(struct sk_buff *skb, int i, int size,
580                          unsigned int truesize)
581{
582        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
583
584        skb_frag_size_add(frag, size);
585        skb->len += size;
586        skb->data_len += size;
587        skb->truesize += truesize;
588}
589EXPORT_SYMBOL(skb_coalesce_rx_frag);
590
591static void skb_drop_list(struct sk_buff **listp)
592{
593        kfree_skb_list(*listp);
594        *listp = NULL;
595}
596
597static inline void skb_drop_fraglist(struct sk_buff *skb)
598{
599        skb_drop_list(&skb_shinfo(skb)->frag_list);
600}
601
602static void skb_clone_fraglist(struct sk_buff *skb)
603{
604        struct sk_buff *list;
605
606        skb_walk_frags(skb, list)
607                skb_get(list);
608}
609
610static void skb_free_head(struct sk_buff *skb)
611{
612        if (skb->head_frag)
613                put_page(virt_to_head_page(skb->head));
614        else
615                kfree(skb->head);
616}
617
618static void skb_release_data(struct sk_buff *skb)
619{
620        struct skb_shared_info *shinfo = skb_shinfo(skb);
621        int i;
622
623        if (skb->cloned &&
624            atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
625                              &shinfo->dataref))
626                return;
627
628        for (i = 0; i < shinfo->nr_frags; i++)
629                __skb_frag_unref(&shinfo->frags[i]);
630
631        /*
632         * If skb buf is from userspace, we need to notify the caller
633         * the lower device DMA has done;
634         */
635        if (shinfo->tx_flags & SKBTX_DEV_ZEROCOPY) {
636                struct ubuf_info *uarg;
637
638                uarg = shinfo->destructor_arg;
639                if (uarg->callback)
640                        uarg->callback(uarg, true);
641        }
642
643        if (shinfo->frag_list)
644                kfree_skb_list(shinfo->frag_list);
645
646        skb_free_head(skb);
647}
648
649/*
650 *      Free an skbuff by memory without cleaning the state.
651 */
652static void kfree_skbmem(struct sk_buff *skb)
653{
654        struct sk_buff_fclones *fclones;
655
656        switch (skb->fclone) {
657        case SKB_FCLONE_UNAVAILABLE:
658                kmem_cache_free(skbuff_head_cache, skb);
659                break;
660
661        case SKB_FCLONE_ORIG:
662                fclones = container_of(skb, struct sk_buff_fclones, skb1);
663                if (atomic_dec_and_test(&fclones->fclone_ref))
664                        kmem_cache_free(skbuff_fclone_cache, fclones);
665                break;
666
667        case SKB_FCLONE_CLONE:
668                fclones = container_of(skb, struct sk_buff_fclones, skb2);
669
670                /* The clone portion is available for
671                 * fast-cloning again.
672                 */
673                skb->fclone = SKB_FCLONE_FREE;
674
675                if (atomic_dec_and_test(&fclones->fclone_ref))
676                        kmem_cache_free(skbuff_fclone_cache, fclones);
677                break;
678        }
679}
680
681static void skb_release_head_state(struct sk_buff *skb)
682{
683        skb_dst_drop(skb);
684#ifdef CONFIG_XFRM
685        secpath_put(skb->sp);
686#endif
687        if (skb->destructor) {
688                WARN_ON(in_irq());
689                skb->destructor(skb);
690        }
691#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
692        /* This should not happen. When it does, avoid memleak by restoring
693        the chain of cb-backups. */
694        while (skb->cb_next != NULL) {
695                if (net_ratelimit())
696                        pr_warn("IMQ: kfree_skb: skb->cb_next: "
697                                "%08x\n", (unsigned int)skb->cb_next);
698
699                skb_restore_cb(skb);
700        }
701        /* This should not happen either, nf_queue_entry is nullified in
702         * imq_dev_xmit(). If we have non-NULL nf_queue_entry then we are
703         * leaking entry pointers, maybe memory. We don't know if this is
704         * pointer to already freed memory, or should this be freed.
705         * If this happens we need to add refcounting, etc for nf_queue_entry.
706         */
707        if (skb->nf_queue_entry && net_ratelimit())
708                pr_warn("%s\n", "IMQ: kfree_skb: skb->nf_queue_entry != NULL");
709#endif
710#if IS_ENABLED(CONFIG_NF_CONNTRACK)
711        nf_conntrack_put(skb->nfct);
712#endif
713#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
714        nf_bridge_put(skb->nf_bridge);
715#endif
716/* XXX: IS this still necessary? - JHS */
717#ifdef CONFIG_NET_SCHED
718        skb->tc_index = 0;
719#ifdef CONFIG_NET_CLS_ACT
720        skb->tc_verd = 0;
721#endif
722#endif
723}
724
725/* Free everything but the sk_buff shell. */
726static void skb_release_all(struct sk_buff *skb)
727{
728        skb_release_head_state(skb);
729        if (likely(skb->head))
730                skb_release_data(skb);
731}
732
733/**
734 *      __kfree_skb - private function
735 *      @skb: buffer
736 *
737 *      Free an sk_buff. Release anything attached to the buffer.
738 *      Clean the state. This is an internal helper function. Users should
739 *      always call kfree_skb
740 */
741
742void __kfree_skb(struct sk_buff *skb)
743{
744        skb_release_all(skb);
745        kfree_skbmem(skb);
746}
747EXPORT_SYMBOL(__kfree_skb);
748
749/**
750 *      kfree_skb - free an sk_buff
751 *      @skb: buffer to free
752 *
753 *      Drop a reference to the buffer and free it if the usage count has
754 *      hit zero.
755 */
756void kfree_skb(struct sk_buff *skb)
757{
758        if (unlikely(!skb))
759                return;
760        if (likely(atomic_read(&skb->users) == 1))
761                smp_rmb();
762        else if (likely(!atomic_dec_and_test(&skb->users)))
763                return;
764        trace_kfree_skb(skb, __builtin_return_address(0));
765        __kfree_skb(skb);
766}
767EXPORT_SYMBOL(kfree_skb);
768
769void kfree_skb_list(struct sk_buff *segs)
770{
771        while (segs) {
772                struct sk_buff *next = segs->next;
773
774                kfree_skb(segs);
775                segs = next;
776        }
777}
778EXPORT_SYMBOL(kfree_skb_list);
779
780/**
781 *      skb_tx_error - report an sk_buff xmit error
782 *      @skb: buffer that triggered an error
783 *
784 *      Report xmit error if a device callback is tracking this skb.
785 *      skb must be freed afterwards.
786 */
787void skb_tx_error(struct sk_buff *skb)
788{
789        if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
790                struct ubuf_info *uarg;
791
792                uarg = skb_shinfo(skb)->destructor_arg;
793                if (uarg->callback)
794                        uarg->callback(uarg, false);
795                skb_shinfo(skb)->tx_flags &= ~SKBTX_DEV_ZEROCOPY;
796        }
797}
798EXPORT_SYMBOL(skb_tx_error);
799
800/**
801 *      consume_skb - free an skbuff
802 *      @skb: buffer to free
803 *
804 *      Drop a ref to the buffer and free it if the usage count has hit zero
805 *      Functions identically to kfree_skb, but kfree_skb assumes that the frame
806 *      is being dropped after a failure and notes that
807 */
808void consume_skb(struct sk_buff *skb)
809{
810        if (unlikely(!skb))
811                return;
812        if (likely(atomic_read(&skb->users) == 1))
813                smp_rmb();
814        else if (likely(!atomic_dec_and_test(&skb->users)))
815                return;
816        trace_consume_skb(skb);
817        __kfree_skb(skb);
818}
819EXPORT_SYMBOL(consume_skb);
820
821/* Make sure a field is enclosed inside headers_start/headers_end section */
822#define CHECK_SKB_FIELD(field) \
823        BUILD_BUG_ON(offsetof(struct sk_buff, field) <          \
824                     offsetof(struct sk_buff, headers_start));  \
825        BUILD_BUG_ON(offsetof(struct sk_buff, field) >          \
826                     offsetof(struct sk_buff, headers_end));    \
827
828static void BCMFASTPATH_HOST __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
829{
830        new->tstamp             = old->tstamp;
831        /* We do not copy old->sk */
832        new->dev                = old->dev;
833        memcpy(new->cb, old->cb, sizeof(old->cb));
834#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
835        new->cb_next = NULL;
836#endif
837        skb_dst_copy(new, old);
838#ifdef CONFIG_XFRM
839        new->sp                 = secpath_get(old->sp);
840#endif
841        __nf_copy(new, old, false);
842
843        /* Note : this field could be in headers_start/headers_end section
844         * It is not yet because we do not want to have a 16 bit hole
845         */
846        new->queue_mapping = old->queue_mapping;
847
848        memcpy(&new->headers_start, &old->headers_start,
849               offsetof(struct sk_buff, headers_end) -
850               offsetof(struct sk_buff, headers_start));
851        CHECK_SKB_FIELD(protocol);
852        CHECK_SKB_FIELD(csum);
853        CHECK_SKB_FIELD(hash);
854        CHECK_SKB_FIELD(priority);
855        CHECK_SKB_FIELD(skb_iif);
856        CHECK_SKB_FIELD(vlan_proto);
857        CHECK_SKB_FIELD(vlan_tci);
858        CHECK_SKB_FIELD(transport_header);
859        CHECK_SKB_FIELD(network_header);
860        CHECK_SKB_FIELD(mac_header);
861        CHECK_SKB_FIELD(inner_protocol);
862        CHECK_SKB_FIELD(inner_transport_header);
863        CHECK_SKB_FIELD(inner_network_header);
864        CHECK_SKB_FIELD(inner_mac_header);
865        CHECK_SKB_FIELD(mark);
866#ifdef CONFIG_NETWORK_SECMARK
867        CHECK_SKB_FIELD(secmark);
868#endif
869#ifdef CONFIG_NET_RX_BUSY_POLL
870        CHECK_SKB_FIELD(napi_id);
871#endif
872#ifdef CONFIG_NET_SCHED
873        CHECK_SKB_FIELD(tc_index);
874#ifdef CONFIG_NET_CLS_ACT
875        CHECK_SKB_FIELD(tc_verd);
876#endif
877#endif
878}
879
880/*
881 * You should not add any new code to this function.  Add it to
882 * __copy_skb_header above instead.
883 */
884static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
885{
886#define C(x) n->x = skb->x
887
888        n->next = n->prev = NULL;
889        n->sk = NULL;
890        __copy_skb_header(n, skb);
891
892        C(len);
893        C(data_len);
894        C(mac_len);
895        n->hdr_len = skb->nohdr ? skb_headroom(skb) : skb->hdr_len;
896        n->cloned = 1;
897        n->nohdr = 0;
898        n->destructor = NULL;
899        C(tail);
900        C(end);
901        C(head);
902        C(head_frag);
903        C(data);
904        C(truesize);
905        atomic_set(&n->users, 1);
906
907        atomic_inc(&(skb_shinfo(skb)->dataref));
908        skb->cloned = 1;
909
910        return n;
911#undef C
912}
913
914/**
915 *      skb_morph       -       morph one skb into another
916 *      @dst: the skb to receive the contents
917 *      @src: the skb to supply the contents
918 *
919 *      This is identical to skb_clone except that the target skb is
920 *      supplied by the user.
921 *
922 *      The target skb is returned upon exit.
923 */
924struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)
925{
926        skb_release_all(dst);
927        return __skb_clone(dst, src);
928}
929EXPORT_SYMBOL_GPL(skb_morph);
930
931/**
932 *      skb_copy_ubufs  -       copy userspace skb frags buffers to kernel
933 *      @skb: the skb to modify
934 *      @gfp_mask: allocation priority
935 *
936 *      This must be called on SKBTX_DEV_ZEROCOPY skb.
937 *      It will copy all frags into kernel and drop the reference
938 *      to userspace pages.
939 *
940 *      If this function is called from an interrupt gfp_mask() must be
941 *      %GFP_ATOMIC.
942 *
943 *      Returns 0 on success or a negative error code on failure
944 *      to allocate kernel memory to copy to.
945 */
946int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)
947{
948        int i;
949        int num_frags = skb_shinfo(skb)->nr_frags;
950        struct page *page, *head = NULL;
951        struct ubuf_info *uarg = skb_shinfo(skb)->destructor_arg;
952
953        for (i = 0; i < num_frags; i++) {
954                u8 *vaddr;
955                skb_frag_t *f = &skb_shinfo(skb)->frags[i];
956
957                page = alloc_page(gfp_mask);
958                if (!page) {
959                        while (head) {
960                                struct page *next = (struct page *)page_private(head);
961                                put_page(head);
962                                head = next;
963                        }
964                        return -ENOMEM;
965                }
966                vaddr = kmap_atomic(skb_frag_page(f));
967                memcpy(page_address(page),
968                       vaddr + f->page_offset, skb_frag_size(f));
969                kunmap_atomic(vaddr);
970                set_page_private(page, (unsigned long)head);
971                head = page;
972        }
973
974        /* skb frags release userspace buffers */
975        for (i = 0; i < num_frags; i++)
976                skb_frag_unref(skb, i);
977
978        uarg->callback(uarg, false);
979
980        /* skb frags point to kernel buffers */
981        for (i = num_frags - 1; i >= 0; i--) {
982                __skb_fill_page_desc(skb, i, head, 0,
983                                     skb_shinfo(skb)->frags[i].size);
984                head = (struct page *)page_private(head);
985        }
986
987        skb_shinfo(skb)->tx_flags &= ~SKBTX_DEV_ZEROCOPY;
988        return 0;
989}
990EXPORT_SYMBOL_GPL(skb_copy_ubufs);
991
992/**
993 *      skb_clone       -       duplicate an sk_buff
994 *      @skb: buffer to clone
995 *      @gfp_mask: allocation priority
996 *
997 *      Duplicate an &sk_buff. The new one is not owned by a socket. Both
998 *      copies share the same packet data but not structure. The new
999 *      buffer has a reference count of 1. If the allocation fails the
1000 *      function returns %NULL otherwise the new buffer is returned.
1001 *
1002 *      If this function is called from an interrupt gfp_mask() must be
1003 *      %GFP_ATOMIC.
1004 */
1005
1006struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
1007{
1008        struct sk_buff_fclones *fclones = container_of(skb,
1009                                                       struct sk_buff_fclones,
1010                                                       skb1);
1011        struct sk_buff *n = &fclones->skb2;
1012
1013        if (skb_orphan_frags(skb, gfp_mask))
1014                return NULL;
1015
1016        if (skb->fclone == SKB_FCLONE_ORIG &&
1017            n->fclone == SKB_FCLONE_FREE) {
1018                n->fclone = SKB_FCLONE_CLONE;
1019                atomic_inc(&fclones->fclone_ref);
1020        } else {
1021                if (skb_pfmemalloc(skb))
1022                        gfp_mask |= __GFP_MEMALLOC;
1023
1024                n = kmem_cache_alloc(skbuff_head_cache, gfp_mask);
1025                if (!n)
1026                        return NULL;
1027
1028                kmemcheck_annotate_bitfield(n, flags1);
1029                n->fclone = SKB_FCLONE_UNAVAILABLE;
1030        }
1031
1032        return __skb_clone(n, skb);
1033}
1034EXPORT_SYMBOL(skb_clone);
1035
1036static void skb_headers_offset_update(struct sk_buff *skb, int off)
1037{
1038        /* Only adjust this if it actually is csum_start rather than csum */
1039        if (skb->ip_summed == CHECKSUM_PARTIAL)
1040                skb->csum_start += off;
1041        /* {transport,network,mac}_header and tail are relative to skb->head */
1042        skb->transport_header += off;
1043        skb->network_header   += off;
1044        if (skb_mac_header_was_set(skb))
1045                skb->mac_header += off;
1046        skb->inner_transport_header += off;
1047        skb->inner_network_header += off;
1048        skb->inner_mac_header += off;
1049}
1050
1051static void copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
1052{
1053        __copy_skb_header(new, old);
1054
1055        skb_shinfo(new)->gso_size = skb_shinfo(old)->gso_size;
1056        skb_shinfo(new)->gso_segs = skb_shinfo(old)->gso_segs;
1057        skb_shinfo(new)->gso_type = skb_shinfo(old)->gso_type;
1058}
1059
1060static inline int skb_alloc_rx_flag(const struct sk_buff *skb)
1061{
1062        if (skb_pfmemalloc(skb))
1063                return SKB_ALLOC_RX;
1064        return 0;
1065}
1066
1067/**
1068 *      skb_copy        -       create private copy of an sk_buff
1069 *      @skb: buffer to copy
1070 *      @gfp_mask: allocation priority
1071 *
1072 *      Make a copy of both an &sk_buff and its data. This is used when the
1073 *      caller wishes to modify the data and needs a private copy of the
1074 *      data to alter. Returns %NULL on failure or the pointer to the buffer
1075 *      on success. The returned buffer has a reference count of 1.
1076 *
1077 *      As by-product this function converts non-linear &sk_buff to linear
1078 *      one, so that &sk_buff becomes completely private and caller is allowed
1079 *      to modify all the data of returned buffer. This means that this
1080 *      function is not recommended for use in circumstances when only
1081 *      header is going to be modified. Use pskb_copy() instead.
1082 */
1083
1084struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)
1085{
1086        int headerlen = skb_headroom(skb);
1087        unsigned int size = skb_end_offset(skb) + skb->data_len;
1088        struct sk_buff *n = __alloc_skb(size, gfp_mask,
1089                                        skb_alloc_rx_flag(skb), NUMA_NO_NODE);
1090
1091        if (!n)
1092                return NULL;
1093
1094        /* Set the data pointer */
1095        skb_reserve(n, headerlen);
1096        /* Set the tail pointer and length */
1097        skb_put(n, skb->len);
1098
1099        if (skb_copy_bits(skb, -headerlen, n->head, headerlen + skb->len))
1100                BUG();
1101
1102        copy_skb_header(n, skb);
1103        return n;
1104}
1105EXPORT_SYMBOL(skb_copy);
1106
1107/**
1108 *      __pskb_copy_fclone      -  create copy of an sk_buff with private head.
1109 *      @skb: buffer to copy
1110 *      @headroom: headroom of new skb
1111 *      @gfp_mask: allocation priority
1112 *      @fclone: if true allocate the copy of the skb from the fclone
1113 *      cache instead of the head cache; it is recommended to set this
1114 *      to true for the cases where the copy will likely be cloned
1115 *
1116 *      Make a copy of both an &sk_buff and part of its data, located
1117 *      in header. Fragmented data remain shared. This is used when
1118 *      the caller wishes to modify only header of &sk_buff and needs
1119 *      private copy of the header to alter. Returns %NULL on failure
1120 *      or the pointer to the buffer on success.
1121 *      The returned buffer has a reference count of 1.
1122 */
1123
1124struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
1125                                   gfp_t gfp_mask, bool fclone)
1126{
1127        unsigned int size = skb_headlen(skb) + headroom;
1128        int flags = skb_alloc_rx_flag(skb) | (fclone ? SKB_ALLOC_FCLONE : 0);
1129        struct sk_buff *n = __alloc_skb(size, gfp_mask, flags, NUMA_NO_NODE);
1130
1131        if (!n)
1132                goto out;
1133
1134        /* Set the data pointer */
1135        skb_reserve(n, headroom);
1136        /* Set the tail pointer and length */
1137        skb_put(n, skb_headlen(skb));
1138        /* Copy the bytes */
1139        skb_copy_from_linear_data(skb, n->data, n->len);
1140
1141        n->truesize += skb->data_len;
1142        n->data_len  = skb->data_len;
1143        n->len       = skb->len;
1144
1145        if (skb_shinfo(skb)->nr_frags) {
1146                int i;
1147
1148                if (skb_orphan_frags(skb, gfp_mask)) {
1149                        kfree_skb(n);
1150                        n = NULL;
1151                        goto out;
1152                }
1153                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1154                        skb_shinfo(n)->frags[i] = skb_shinfo(skb)->frags[i];
1155                        skb_frag_ref(skb, i);
1156                }
1157                skb_shinfo(n)->nr_frags = i;
1158        }
1159
1160        if (skb_has_frag_list(skb)) {
1161                skb_shinfo(n)->frag_list = skb_shinfo(skb)->frag_list;
1162                skb_clone_fraglist(n);
1163        }
1164
1165        copy_skb_header(n, skb);
1166out:
1167        return n;
1168}
1169EXPORT_SYMBOL(__pskb_copy_fclone);
1170
1171/**
1172 *      pskb_expand_head - reallocate header of &sk_buff
1173 *      @skb: buffer to reallocate
1174 *      @nhead: room to add at head
1175 *      @ntail: room to add at tail
1176 *      @gfp_mask: allocation priority
1177 *
1178 *      Expands (or creates identical copy, if @nhead and @ntail are zero)
1179 *      header of @skb. &sk_buff itself is not changed. &sk_buff MUST have
1180 *      reference count of 1. Returns zero in the case of success or error,
1181 *      if expansion failed. In the last case, &sk_buff is not changed.
1182 *
1183 *      All the pointers pointing into skb header may change and must be
1184 *      reloaded after call to this function.
1185 */
1186
1187int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail,
1188                     gfp_t gfp_mask)
1189{
1190        int i;
1191        u8 *data;
1192        int size = nhead + skb_end_offset(skb) + ntail;
1193        long off;
1194
1195        BUG_ON(nhead < 0);
1196
1197        if (skb_shared(skb))
1198                BUG();
1199
1200#ifdef CONFIG_ARCH_IXP4XX
1201        gfp_mask |= GFP_DMA;
1202#endif
1203
1204        size = SKB_DATA_ALIGN(size);
1205
1206        if (skb_pfmemalloc(skb))
1207                gfp_mask |= __GFP_MEMALLOC;
1208        data = kmalloc_reserve(size + SKB_DATA_ALIGN(sizeof(struct skb_shared_info)),
1209                               gfp_mask, NUMA_NO_NODE, NULL);
1210        if (!data)
1211                goto nodata;
1212        size = SKB_WITH_OVERHEAD(ksize(data));
1213
1214        /* Copy only real data... and, alas, header. This should be
1215         * optimized for the cases when header is void.
1216         */
1217        memcpy(data + nhead, skb->head, skb_tail_pointer(skb) - skb->head);
1218
1219        memcpy((struct skb_shared_info *)(data + size),
1220               skb_shinfo(skb),
1221               offsetof(struct skb_shared_info, frags[skb_shinfo(skb)->nr_frags]));
1222
1223        /*
1224         * if shinfo is shared we must drop the old head gracefully, but if it
1225         * is not we can just drop the old head and let the existing refcount
1226         * be since all we did is relocate the values
1227         */
1228        if (skb_cloned(skb)) {
1229                /* copy this zero copy skb frags */
1230                if (skb_orphan_frags(skb, gfp_mask))
1231                        goto nofrags;
1232                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1233                        skb_frag_ref(skb, i);
1234
1235                if (skb_has_frag_list(skb))
1236                        skb_clone_fraglist(skb);
1237
1238                skb_release_data(skb);
1239        } else {
1240                skb_free_head(skb);
1241        }
1242        off = (data + nhead) - skb->head;
1243
1244        skb->head     = data;
1245        skb->head_frag = 0;
1246        skb->data    += off;
1247#ifdef NET_SKBUFF_DATA_USES_OFFSET
1248        skb->end      = size;
1249        off           = nhead;
1250#else
1251        skb->end      = skb->head + size;
1252#endif
1253        skb->tail             += off;
1254        skb_headers_offset_update(skb, nhead);
1255        skb->cloned   = 0;
1256        skb->hdr_len  = 0;
1257        skb->nohdr    = 0;
1258        atomic_set(&skb_shinfo(skb)->dataref, 1);
1259        return 0;
1260
1261nofrags:
1262        kfree(data);
1263nodata:
1264        return -ENOMEM;
1265}
1266EXPORT_SYMBOL(pskb_expand_head);
1267
1268/* Make private copy of skb with writable head and some headroom */
1269
1270struct sk_buff *skb_realloc_headroom(struct sk_buff *skb, unsigned int headroom)
1271{
1272        struct sk_buff *skb2;
1273        int delta = headroom - skb_headroom(skb);
1274
1275        if (delta <= 0)
1276                skb2 = pskb_copy(skb, GFP_ATOMIC);
1277        else {
1278                skb2 = skb_clone(skb, GFP_ATOMIC);
1279                if (skb2 && pskb_expand_head(skb2, SKB_DATA_ALIGN(delta), 0,
1280                                             GFP_ATOMIC)) {
1281                        kfree_skb(skb2);
1282                        skb2 = NULL;
1283                }
1284        }
1285        return skb2;
1286}
1287EXPORT_SYMBOL(skb_realloc_headroom);
1288
1289/**
1290 *      skb_copy_expand -       copy and expand sk_buff
1291 *      @skb: buffer to copy
1292 *      @newheadroom: new free bytes at head
1293 *      @newtailroom: new free bytes at tail
1294 *      @gfp_mask: allocation priority
1295 *
1296 *      Make a copy of both an &sk_buff and its data and while doing so
1297 *      allocate additional space.
1298 *
1299 *      This is used when the caller wishes to modify the data and needs a
1300 *      private copy of the data to alter as well as more space for new fields.
1301 *      Returns %NULL on failure or the pointer to the buffer
1302 *      on success. The returned buffer has a reference count of 1.
1303 *
1304 *      You must pass %GFP_ATOMIC as the allocation priority if this function
1305 *      is called from an interrupt.
1306 */
1307struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
1308                                int newheadroom, int newtailroom,
1309                                gfp_t gfp_mask)
1310{
1311        /*
1312         *      Allocate the copy buffer
1313         */
1314        struct sk_buff *n = __alloc_skb(newheadroom + skb->len + newtailroom,
1315                                        gfp_mask, skb_alloc_rx_flag(skb),
1316                                        NUMA_NO_NODE);
1317        int oldheadroom = skb_headroom(skb);
1318        int head_copy_len, head_copy_off;
1319
1320        if (!n)
1321                return NULL;
1322
1323        skb_reserve(n, newheadroom);
1324
1325        /* Set the tail pointer and length */
1326        skb_put(n, skb->len);
1327
1328        head_copy_len = oldheadroom;
1329        head_copy_off = 0;
1330        if (newheadroom <= head_copy_len)
1331                head_copy_len = newheadroom;
1332        else
1333                head_copy_off = newheadroom - head_copy_len;
1334
1335        /* Copy the linear header and data. */
1336        if (skb_copy_bits(skb, -head_copy_len, n->head + head_copy_off,
1337                          skb->len + head_copy_len))
1338                BUG();
1339
1340        copy_skb_header(n, skb);
1341
1342        skb_headers_offset_update(n, newheadroom - oldheadroom);
1343
1344        return n;
1345}
1346EXPORT_SYMBOL(skb_copy_expand);
1347
1348/**
1349 *      skb_pad                 -       zero pad the tail of an skb
1350 *      @skb: buffer to pad
1351 *      @pad: space to pad
1352 *
1353 *      Ensure that a buffer is followed by a padding area that is zero
1354 *      filled. Used by network drivers which may DMA or transfer data
1355 *      beyond the buffer end onto the wire.
1356 *
1357 *      May return error in out of memory cases. The skb is freed on error.
1358 */
1359
1360int skb_pad(struct sk_buff *skb, int pad)
1361{
1362        int err;
1363        int ntail;
1364
1365        /* If the skbuff is non linear tailroom is always zero.. */
1366        if (!skb_cloned(skb) && skb_tailroom(skb) >= pad) {
1367                memset(skb->data+skb->len, 0, pad);
1368                return 0;
1369        }
1370
1371        ntail = skb->data_len + pad - (skb->end - skb->tail);
1372        if (likely(skb_cloned(skb) || ntail > 0)) {
1373                err = pskb_expand_head(skb, 0, ntail, GFP_ATOMIC);
1374                if (unlikely(err))
1375                        goto free_skb;
1376        }
1377
1378        /* FIXME: The use of this function with non-linear skb's really needs
1379         * to be audited.
1380         */
1381        err = skb_linearize(skb);
1382        if (unlikely(err))
1383                goto free_skb;
1384
1385        memset(skb->data + skb->len, 0, pad);
1386        return 0;
1387
1388free_skb:
1389        kfree_skb(skb);
1390        return err;
1391}
1392EXPORT_SYMBOL(skb_pad);
1393
1394/**
1395 *      pskb_put - add data to the tail of a potentially fragmented buffer
1396 *      @skb: start of the buffer to use
1397 *      @tail: tail fragment of the buffer to use
1398 *      @len: amount of data to add
1399 *
1400 *      This function extends the used data area of the potentially
1401 *      fragmented buffer. @tail must be the last fragment of @skb -- or
1402 *      @skb itself. If this would exceed the total buffer size the kernel
1403 *      will panic. A pointer to the first byte of the extra data is
1404 *      returned.
1405 */
1406
1407unsigned char *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
1408{
1409        if (tail != skb) {
1410                skb->data_len += len;
1411                skb->len += len;
1412        }
1413        return skb_put(tail, len);
1414}
1415EXPORT_SYMBOL_GPL(pskb_put);
1416
1417/**
1418 *      skb_put - add data to a buffer
1419 *      @skb: buffer to use
1420 *      @len: amount of data to add
1421 *
1422 *      This function extends the used data area of the buffer. If this would
1423 *      exceed the total buffer size the kernel will panic. A pointer to the
1424 *      first byte of the extra data is returned.
1425 */
1426unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
1427{
1428        unsigned char *tmp = skb_tail_pointer(skb);
1429        SKB_LINEAR_ASSERT(skb);
1430        skb->tail += len;
1431        skb->len  += len;
1432        if (unlikely(skb->tail > skb->end))
1433                skb_over_panic(skb, len, __builtin_return_address(0));
1434        return tmp;
1435}
1436EXPORT_SYMBOL(skb_put);
1437
1438/**
1439 *      skb_push - add data to the start of a buffer
1440 *      @skb: buffer to use
1441 *      @len: amount of data to add
1442 *
1443 *      This function extends the used data area of the buffer at the buffer
1444 *      start. If this would exceed the total buffer headroom the kernel will
1445 *      panic. A pointer to the first byte of the extra data is returned.
1446 */
1447unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
1448{
1449        skb->data -= len;
1450        skb->len  += len;
1451        if (unlikely(skb->data<skb->head))
1452                skb_under_panic(skb, len, __builtin_return_address(0));
1453        return skb->data;
1454}
1455EXPORT_SYMBOL(skb_push);
1456
1457/**
1458 *      skb_pull - remove data from the start of a buffer
1459 *      @skb: buffer to use
1460 *      @len: amount of data to remove
1461 *
1462 *      This function removes data from the start of a buffer, returning
1463 *      the memory to the headroom. A pointer to the next data in the buffer
1464 *      is returned. Once the data has been pulled future pushes will overwrite
1465 *      the old data.
1466 */
1467unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
1468{
1469        return skb_pull_inline(skb, len);
1470}
1471EXPORT_SYMBOL(skb_pull);
1472
1473/**
1474 *      skb_trim - remove end from a buffer
1475 *      @skb: buffer to alter
1476 *      @len: new length
1477 *
1478 *      Cut the length of a buffer down by removing data from the tail. If
1479 *      the buffer is already under the length specified it is not modified.
1480 *      The skb must be linear.
1481 */
1482void skb_trim(struct sk_buff *skb, unsigned int len)
1483{
1484        if (skb->len > len)
1485                __skb_trim(skb, len);
1486}
1487EXPORT_SYMBOL(skb_trim);
1488
1489/* Trims skb to length len. It can change skb pointers.
1490 */
1491
1492int ___pskb_trim(struct sk_buff *skb, unsigned int len)
1493{
1494        struct sk_buff **fragp;
1495        struct sk_buff *frag;
1496        int offset = skb_headlen(skb);
1497        int nfrags = skb_shinfo(skb)->nr_frags;
1498        int i;
1499        int err;
1500
1501        if (skb_cloned(skb) &&
1502            unlikely((err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))))
1503                return err;
1504
1505        i = 0;
1506        if (offset >= len)
1507                goto drop_pages;
1508
1509        for (; i < nfrags; i++) {
1510                int end = offset + skb_frag_size(&skb_shinfo(skb)->frags[i]);
1511
1512                if (end < len) {
1513                        offset = end;
1514                        continue;
1515                }
1516
1517                skb_frag_size_set(&skb_shinfo(skb)->frags[i++], len - offset);
1518
1519drop_pages:
1520                skb_shinfo(skb)->nr_frags = i;
1521
1522                for (; i < nfrags; i++)
1523                        skb_frag_unref(skb, i);
1524
1525                if (skb_has_frag_list(skb))
1526                        skb_drop_fraglist(skb);
1527                goto done;
1528        }
1529
1530        for (fragp = &skb_shinfo(skb)->frag_list; (frag = *fragp);
1531             fragp = &frag->next) {
1532                int end = offset + frag->len;
1533
1534                if (skb_shared(frag)) {
1535                        struct sk_buff *nfrag;
1536
1537                        nfrag = skb_clone(frag, GFP_ATOMIC);
1538                        if (unlikely(!nfrag))
1539                                return -ENOMEM;
1540
1541                        nfrag->next = frag->next;
1542                        consume_skb(frag);
1543                        frag = nfrag;
1544                        *fragp = frag;
1545                }
1546
1547                if (end < len) {
1548                        offset = end;
1549                        continue;
1550                }
1551
1552                if (end > len &&
1553                    unlikely((err = pskb_trim(frag, len - offset))))
1554                        return err;
1555
1556                if (frag->next)
1557                        skb_drop_list(&frag->next);
1558                break;
1559        }
1560
1561done:
1562        if (len > skb_headlen(skb)) {
1563                skb->data_len -= skb->len - len;
1564                skb->len       = len;
1565        } else {
1566                skb->len       = len;
1567                skb->data_len  = 0;
1568                skb_set_tail_pointer(skb, len);
1569        }
1570
1571        return 0;
1572}
1573EXPORT_SYMBOL(___pskb_trim);
1574
1575/**
1576 *      __pskb_pull_tail - advance tail of skb header
1577 *      @skb: buffer to reallocate
1578 *      @delta: number of bytes to advance tail
1579 *
1580 *      The function makes a sense only on a fragmented &sk_buff,
1581 *      it expands header moving its tail forward and copying necessary
1582 *      data from fragmented part.
1583 *
1584 *      &sk_buff MUST have reference count of 1.
1585 *
1586 *      Returns %NULL (and &sk_buff does not change) if pull failed
1587 *      or value of new tail of skb in the case of success.
1588 *
1589 *      All the pointers pointing into skb header may change and must be
1590 *      reloaded after call to this function.
1591 */
1592
1593/* Moves tail of skb head forward, copying data from fragmented part,
1594 * when it is necessary.
1595 * 1. It may fail due to malloc failure.
1596 * 2. It may change skb pointers.
1597 *
1598 * It is pretty complicated. Luckily, it is called only in exceptional cases.
1599 */
1600unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)
1601{
1602        /* If skb has not enough free space at tail, get new one
1603         * plus 128 bytes for future expansions. If we have enough
1604         * room at tail, reallocate without expansion only if skb is cloned.
1605         */
1606        int i, k, eat = (skb->tail + delta) - skb->end;
1607
1608        if (eat > 0 || skb_cloned(skb)) {
1609                if (pskb_expand_head(skb, 0, eat > 0 ? eat + 128 : 0,
1610                                     GFP_ATOMIC))
1611                        return NULL;
1612        }
1613
1614        if (skb_copy_bits(skb, skb_headlen(skb), skb_tail_pointer(skb), delta))
1615                BUG();
1616
1617        /* Optimization: no fragments, no reasons to preestimate
1618         * size of pulled pages. Superb.
1619         */
1620        if (!skb_has_frag_list(skb))
1621                goto pull_pages;
1622
1623        /* Estimate size of pulled pages. */
1624        eat = delta;
1625        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1626                int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
1627
1628                if (size >= eat)
1629                        goto pull_pages;
1630                eat -= size;
1631        }
1632
1633        /* If we need update frag list, we are in troubles.
1634         * Certainly, it possible to add an offset to skb data,
1635         * but taking into account that pulling is expected to
1636         * be very rare operation, it is worth to fight against
1637         * further bloating skb head and crucify ourselves here instead.
1638         * Pure masohism, indeed. 8)8)
1639         */
1640        if (eat) {
1641                struct sk_buff *list = skb_shinfo(skb)->frag_list;
1642                struct sk_buff *clone = NULL;
1643                struct sk_buff *insp = NULL;
1644
1645                do {
1646                        BUG_ON(!list);
1647
1648                        if (list->len <= eat) {
1649                                /* Eaten as whole. */
1650                                eat -= list->len;
1651                                list = list->next;
1652                                insp = list;
1653                        } else {
1654                                /* Eaten partially. */
1655
1656                                if (skb_shared(list)) {
1657                                        /* Sucks! We need to fork list. :-( */
1658                                        clone = skb_clone(list, GFP_ATOMIC);
1659                                        if (!clone)
1660                                                return NULL;
1661                                        insp = list->next;
1662                                        list = clone;
1663                                } else {
1664                                        /* This may be pulled without
1665                                         * problems. */
1666                                        insp = list;
1667                                }
1668                                if (!pskb_pull(list, eat)) {
1669                                        kfree_skb(clone);
1670                                        return NULL;
1671                                }
1672                                break;
1673                        }
1674                } while (eat);
1675
1676                /* Free pulled out fragments. */
1677                while ((list = skb_shinfo(skb)->frag_list) != insp) {
1678                        skb_shinfo(skb)->frag_list = list->next;
1679                        kfree_skb(list);
1680                }
1681                /* And insert new clone at head. */
1682                if (clone) {
1683                        clone->next = list;
1684                        skb_shinfo(skb)->frag_list = clone;
1685                }
1686        }
1687        /* Success! Now we may commit changes to skb data. */
1688
1689pull_pages:
1690        eat = delta;
1691        k = 0;
1692        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1693                int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
1694
1695                if (size <= eat) {
1696                        skb_frag_unref(skb, i);
1697                        eat -= size;
1698                } else {
1699                        skb_shinfo(skb)->frags[k] = skb_shinfo(skb)->frags[i];
1700                        if (eat) {
1701                                skb_shinfo(skb)->frags[k].page_offset += eat;
1702                                skb_frag_size_sub(&skb_shinfo(skb)->frags[k], eat);
1703                                eat = 0;
1704                        }
1705                        k++;
1706                }
1707        }
1708        skb_shinfo(skb)->nr_frags = k;
1709
1710        skb->tail     += delta;
1711        skb->data_len -= delta;
1712
1713        return skb_tail_pointer(skb);
1714}
1715EXPORT_SYMBOL(__pskb_pull_tail);
1716
1717/**
1718 *      skb_copy_bits - copy bits from skb to kernel buffer
1719 *      @skb: source skb
1720 *      @offset: offset in source
1721 *      @to: destination buffer
1722 *      @len: number of bytes to copy
1723 *
1724 *      Copy the specified number of bytes from the source skb to the
1725 *      destination buffer.
1726 *
1727 *      CAUTION ! :
1728 *              If its prototype is ever changed,
1729 *              check arch/{*}/net/{*}.S files,
1730 *              since it is called from BPF assembly code.
1731 */
1732int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)
1733{
1734        int start = skb_headlen(skb);
1735        struct sk_buff *frag_iter;
1736        int i, copy;
1737
1738        if (offset > (int)skb->len - len)
1739                goto fault;
1740
1741        /* Copy header. */
1742        if ((copy = start - offset) > 0) {
1743                if (copy > len)
1744                        copy = len;
1745                skb_copy_from_linear_data_offset(skb, offset, to, copy);
1746                if ((len -= copy) == 0)
1747                        return 0;
1748                offset += copy;
1749                to     += copy;
1750        }
1751
1752        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1753                int end;
1754                skb_frag_t *f = &skb_shinfo(skb)->frags[i];
1755
1756                WARN_ON(start > offset + len);
1757
1758                end = start + skb_frag_size(f);
1759                if ((copy = end - offset) > 0) {
1760                        u8 *vaddr;
1761
1762                        if (copy > len)
1763                                copy = len;
1764
1765                        vaddr = kmap_atomic(skb_frag_page(f));
1766                        memcpy(to,
1767                               vaddr + f->page_offset + offset - start,
1768                               copy);
1769                        kunmap_atomic(vaddr);
1770
1771                        if ((len -= copy) == 0)
1772                                return 0;
1773                        offset += copy;
1774                        to     += copy;
1775                }
1776                start = end;
1777        }
1778
1779        skb_walk_frags(skb, frag_iter) {
1780                int end;
1781
1782                WARN_ON(start > offset + len);
1783
1784                end = start + frag_iter->len;
1785                if ((copy = end - offset) > 0) {
1786                        if (copy > len)
1787                                copy = len;
1788                        if (skb_copy_bits(frag_iter, offset - start, to, copy))
1789                                goto fault;
1790                        if ((len -= copy) == 0)
1791                                return 0;
1792                        offset += copy;
1793                        to     += copy;
1794                }
1795                start = end;
1796        }
1797
1798        if (!len)
1799                return 0;
1800
1801fault:
1802        return -EFAULT;
1803}
1804EXPORT_SYMBOL(skb_copy_bits);
1805
1806/*
1807 * Callback from splice_to_pipe(), if we need to release some pages
1808 * at the end of the spd in case we error'ed out in filling the pipe.
1809 */
1810static void sock_spd_release(struct splice_pipe_desc *spd, unsigned int i)
1811{
1812        put_page(spd->pages[i]);
1813}
1814
1815static struct page *linear_to_page(struct page *page, unsigned int *len,
1816                                   unsigned int *offset,
1817                                   struct sock *sk)
1818{
1819        struct page_frag *pfrag = sk_page_frag(sk);
1820
1821        if (!sk_page_frag_refill(sk, pfrag))
1822                return NULL;
1823
1824        *len = min_t(unsigned int, *len, pfrag->size - pfrag->offset);
1825
1826        memcpy(page_address(pfrag->page) + pfrag->offset,
1827               page_address(page) + *offset, *len);
1828        *offset = pfrag->offset;
1829        pfrag->offset += *len;
1830
1831        return pfrag->page;
1832}
1833
1834static bool spd_can_coalesce(const struct splice_pipe_desc *spd,
1835                             struct page *page,
1836                             unsigned int offset)
1837{
1838        return  spd->nr_pages &&
1839                spd->pages[spd->nr_pages - 1] == page &&
1840                (spd->partial[spd->nr_pages - 1].offset +
1841                 spd->partial[spd->nr_pages - 1].len == offset);
1842}
1843
1844/*
1845 * Fill page/offset/length into spd, if it can hold more pages.
1846 */
1847static bool spd_fill_page(struct splice_pipe_desc *spd,
1848                          struct pipe_inode_info *pipe, struct page *page,
1849                          unsigned int *len, unsigned int offset,
1850                          bool linear,
1851                          struct sock *sk)
1852{
1853        if (unlikely(spd->nr_pages == MAX_SKB_FRAGS))
1854                return true;
1855
1856        if (linear) {
1857                page = linear_to_page(page, len, &offset, sk);
1858                if (!page)
1859                        return true;
1860        }
1861        if (spd_can_coalesce(spd, page, offset)) {
1862                spd->partial[spd->nr_pages - 1].len += *len;
1863                return false;
1864        }
1865        get_page(page);
1866        spd->pages[spd->nr_pages] = page;
1867        spd->partial[spd->nr_pages].len = *len;
1868        spd->partial[spd->nr_pages].offset = offset;
1869        spd->nr_pages++;
1870
1871        return false;
1872}
1873
1874static bool __splice_segment(struct page *page, unsigned int poff,
1875                             unsigned int plen, unsigned int *off,
1876                             unsigned int *len,
1877                             struct splice_pipe_desc *spd, bool linear,
1878                             struct sock *sk,
1879                             struct pipe_inode_info *pipe)
1880{
1881        if (!*len)
1882                return true;
1883
1884        /* skip this segment if already processed */
1885        if (*off >= plen) {
1886                *off -= plen;
1887                return false;
1888        }
1889
1890        /* ignore any bits we already processed */
1891        poff += *off;
1892        plen -= *off;
1893        *off = 0;
1894
1895        do {
1896                unsigned int flen = min(*len, plen);
1897
1898                if (spd_fill_page(spd, pipe, page, &flen, poff,
1899                                  linear, sk))
1900                        return true;
1901                poff += flen;
1902                plen -= flen;
1903                *len -= flen;
1904        } while (*len && plen);
1905
1906        return false;
1907}
1908
1909/*
1910 * Map linear and fragment data from the skb to spd. It reports true if the
1911 * pipe is full or if we already spliced the requested length.
1912 */
1913static bool __skb_splice_bits(struct sk_buff *skb, struct pipe_inode_info *pipe,
1914                              unsigned int *offset, unsigned int *len,
1915                              struct splice_pipe_desc *spd, struct sock *sk)
1916{
1917        int seg;
1918
1919        /* map the linear part :
1920         * If skb->head_frag is set, this 'linear' part is backed by a
1921         * fragment, and if the head is not shared with any clones then
1922         * we can avoid a copy since we own the head portion of this page.
1923         */
1924        if (__splice_segment(virt_to_page(skb->data),
1925                             (unsigned long) skb->data & (PAGE_SIZE - 1),
1926                             skb_headlen(skb),
1927                             offset, len, spd,
1928                             skb_head_is_locked(skb),
1929                             sk, pipe))
1930                return true;
1931
1932        /*
1933         * then map the fragments
1934         */
1935        for (seg = 0; seg < skb_shinfo(skb)->nr_frags; seg++) {
1936                const skb_frag_t *f = &skb_shinfo(skb)->frags[seg];
1937
1938                if (__splice_segment(skb_frag_page(f),
1939                                     f->page_offset, skb_frag_size(f),
1940                                     offset, len, spd, false, sk, pipe))
1941                        return true;
1942        }
1943
1944        return false;
1945}
1946
1947/*
1948 * Map data from the skb to a pipe. Should handle both the linear part,
1949 * the fragments, and the frag list. It does NOT handle frag lists within
1950 * the frag list, if such a thing exists. We'd probably need to recurse to
1951 * handle that cleanly.
1952 */
1953int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
1954                    struct pipe_inode_info *pipe, unsigned int tlen,
1955                    unsigned int flags)
1956{
1957        struct partial_page partial[MAX_SKB_FRAGS];
1958        struct page *pages[MAX_SKB_FRAGS];
1959        struct splice_pipe_desc spd = {
1960                .pages = pages,
1961                .partial = partial,
1962                .nr_pages_max = MAX_SKB_FRAGS,
1963                .flags = flags,
1964                .ops = &nosteal_pipe_buf_ops,
1965                .spd_release = sock_spd_release,
1966        };
1967        struct sk_buff *frag_iter;
1968        struct sock *sk = skb->sk;
1969        int ret = 0;
1970
1971        /*
1972         * __skb_splice_bits() only fails if the output has no room left,
1973         * so no point in going over the frag_list for the error case.
1974         */
1975        if (__skb_splice_bits(skb, pipe, &offset, &tlen, &spd, sk))
1976                goto done;
1977        else if (!tlen)
1978                goto done;
1979
1980        /*
1981         * now see if we have a frag_list to map
1982         */
1983        skb_walk_frags(skb, frag_iter) {
1984                if (!tlen)
1985                        break;
1986                if (__skb_splice_bits(frag_iter, pipe, &offset, &tlen, &spd, sk))
1987                        break;
1988        }
1989
1990done:
1991        if (spd.nr_pages) {
1992                /*
1993                 * Drop the socket lock, otherwise we have reverse
1994                 * locking dependencies between sk_lock and i_mutex
1995                 * here as compared to sendfile(). We enter here
1996                 * with the socket lock held, and splice_to_pipe() will
1997                 * grab the pipe inode lock. For sendfile() emulation,
1998                 * we call into ->sendpage() with the i_mutex lock held
1999                 * and networking will grab the socket lock.
2000                 */
2001                release_sock(sk);
2002                ret = splice_to_pipe(pipe, &spd);
2003                lock_sock(sk);
2004        }
2005
2006        return ret;
2007}
2008
2009/**
2010 *      skb_store_bits - store bits from kernel buffer to skb
2011 *      @skb: destination buffer
2012 *      @offset: offset in destination
2013 *      @from: source buffer
2014 *      @len: number of bytes to copy
2015 *
2016 *      Copy the specified number of bytes from the source buffer to the
2017 *      destination skb.  This function handles all the messy bits of
2018 *      traversing fragment lists and such.
2019 */
2020
2021int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)
2022{
2023        int start = skb_headlen(skb);
2024        struct sk_buff *frag_iter;
2025        int i, copy;
2026
2027        if (offset > (int)skb->len - len)
2028                goto fault;
2029
2030        if ((copy = start - offset) > 0) {
2031                if (copy > len)
2032                        copy = len;
2033                skb_copy_to_linear_data_offset(skb, offset, from, copy);
2034                if ((len -= copy) == 0)
2035                        return 0;
2036                offset += copy;
2037                from += copy;
2038        }
2039
2040        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2041                skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2042                int end;
2043
2044                WARN_ON(start > offset + len);
2045
2046                end = start + skb_frag_size(frag);
2047                if ((copy = end - offset) > 0) {
2048                        u8 *vaddr;
2049
2050                        if (copy > len)
2051                                copy = len;
2052
2053                        vaddr = kmap_atomic(skb_frag_page(frag));
2054                        memcpy(vaddr + frag->page_offset + offset - start,
2055                               from, copy);
2056                        kunmap_atomic(vaddr);
2057
2058                        if ((len -= copy) == 0)
2059                                return 0;
2060                        offset += copy;
2061                        from += copy;
2062                }
2063                start = end;
2064        }
2065
2066        skb_walk_frags(skb, frag_iter) {
2067                int end;
2068
2069                WARN_ON(start > offset + len);
2070
2071                end = start + frag_iter->len;
2072                if ((copy = end - offset) > 0) {
2073                        if (copy > len)
2074                                copy = len;
2075                        if (skb_store_bits(frag_iter, offset - start,
2076                                           from, copy))
2077                                goto fault;
2078                        if ((len -= copy) == 0)
2079                                return 0;
2080                        offset += copy;
2081                        from += copy;
2082                }
2083                start = end;
2084        }
2085        if (!len)
2086                return 0;
2087
2088fault:
2089        return -EFAULT;
2090}
2091EXPORT_SYMBOL(skb_store_bits);
2092
2093/* Checksum skb data. */
2094__wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
2095                      __wsum csum, const struct skb_checksum_ops *ops)
2096{
2097        int start = skb_headlen(skb);
2098        int i, copy = start - offset;
2099        struct sk_buff *frag_iter;
2100        int pos = 0;
2101
2102        /* Checksum header. */
2103        if (copy > 0) {
2104                if (copy > len)
2105                        copy = len;
2106                csum = ops->update(skb->data + offset, copy, csum);
2107                if ((len -= copy) == 0)
2108                        return csum;
2109                offset += copy;
2110                pos     = copy;
2111        }
2112
2113        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2114                int end;
2115                skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2116
2117                WARN_ON(start > offset + len);
2118
2119                end = start + skb_frag_size(frag);
2120                if ((copy = end - offset) > 0) {
2121                        __wsum csum2;
2122                        u8 *vaddr;
2123
2124                        if (copy > len)
2125                                copy = len;
2126                        vaddr = kmap_atomic(skb_frag_page(frag));
2127                        csum2 = ops->update(vaddr + frag->page_offset +
2128                                            offset - start, copy, 0);
2129                        kunmap_atomic(vaddr);
2130                        csum = ops->combine(csum, csum2, pos, copy);
2131                        if (!(len -= copy))
2132                                return csum;
2133                        offset += copy;
2134                        pos    += copy;
2135                }
2136                start = end;
2137        }
2138
2139        skb_walk_frags(skb, frag_iter) {
2140                int end;
2141
2142                WARN_ON(start > offset + len);
2143
2144                end = start + frag_iter->len;
2145                if ((copy = end - offset) > 0) {
2146                        __wsum csum2;
2147                        if (copy > len)
2148                                copy = len;
2149                        csum2 = __skb_checksum(frag_iter, offset - start,
2150                                               copy, 0, ops);
2151                        csum = ops->combine(csum, csum2, pos, copy);
2152                        if ((len -= copy) == 0)
2153                                return csum;
2154                        offset += copy;
2155                        pos    += copy;
2156                }
2157                start = end;
2158        }
2159        BUG_ON(len);
2160
2161        return csum;
2162}
2163EXPORT_SYMBOL(__skb_checksum);
2164
2165__wsum skb_checksum(const struct sk_buff *skb, int offset,
2166                    int len, __wsum csum)
2167{
2168        const struct skb_checksum_ops ops = {
2169                .update  = csum_partial_ext,
2170                .combine = csum_block_add_ext,
2171        };
2172
2173        return __skb_checksum(skb, offset, len, csum, &ops);
2174}
2175EXPORT_SYMBOL(skb_checksum);
2176
2177/* Both of above in one bottle. */
2178
2179__wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset,
2180                                    u8 *to, int len, __wsum csum)
2181{
2182        int start = skb_headlen(skb);
2183        int i, copy = start - offset;
2184        struct sk_buff *frag_iter;
2185        int pos = 0;
2186
2187        /* Copy header. */
2188        if (copy > 0) {
2189                if (copy > len)
2190                        copy = len;
2191                csum = csum_partial_copy_nocheck(skb->data + offset, to,
2192                                                 copy, csum);
2193                if ((len -= copy) == 0)
2194                        return csum;
2195                offset += copy;
2196                to     += copy;
2197                pos     = copy;
2198        }
2199
2200        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2201                int end;
2202
2203                WARN_ON(start > offset + len);
2204
2205                end = start + skb_frag_size(&skb_shinfo(skb)->frags[i]);
2206                if ((copy = end - offset) > 0) {
2207                        __wsum csum2;
2208                        u8 *vaddr;
2209                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2210
2211                        if (copy > len)
2212                                copy = len;
2213                        vaddr = kmap_atomic(skb_frag_page(frag));
2214                        csum2 = csum_partial_copy_nocheck(vaddr +
2215                                                          frag->page_offset +
2216                                                          offset - start, to,
2217                                                          copy, 0);
2218                        kunmap_atomic(vaddr);
2219                        csum = csum_block_add(csum, csum2, pos);
2220                        if (!(len -= copy))
2221                                return csum;
2222                        offset += copy;
2223                        to     += copy;
2224                        pos    += copy;
2225                }
2226                start = end;
2227        }
2228
2229        skb_walk_frags(skb, frag_iter) {
2230                __wsum csum2;
2231                int end;
2232
2233                WARN_ON(start > offset + len);
2234
2235                end = start + frag_iter->len;
2236                if ((copy = end - offset) > 0) {
2237                        if (copy > len)
2238                                copy = len;
2239                        csum2 = skb_copy_and_csum_bits(frag_iter,
2240                                                       offset - start,
2241                                                       to, copy, 0);
2242                        csum = csum_block_add(csum, csum2, pos);
2243                        if ((len -= copy) == 0)
2244                                return csum;
2245                        offset += copy;
2246                        to     += copy;
2247                        pos    += copy;
2248                }
2249                start = end;
2250        }
2251        BUG_ON(len);
2252        return csum;
2253}
2254EXPORT_SYMBOL(skb_copy_and_csum_bits);
2255
2256 /**
2257 *      skb_zerocopy_headlen - Calculate headroom needed for skb_zerocopy()
2258 *      @from: source buffer
2259 *
2260 *      Calculates the amount of linear headroom needed in the 'to' skb passed
2261 *      into skb_zerocopy().
2262 */
2263unsigned int
2264skb_zerocopy_headlen(const struct sk_buff *from)
2265{
2266        unsigned int hlen = 0;
2267
2268        if (!from->head_frag ||
2269            skb_headlen(from) < L1_CACHE_BYTES ||
2270            skb_shinfo(from)->nr_frags >= MAX_SKB_FRAGS)
2271                hlen = skb_headlen(from);
2272
2273        if (skb_has_frag_list(from))
2274                hlen = from->len;
2275
2276        return hlen;
2277}
2278EXPORT_SYMBOL_GPL(skb_zerocopy_headlen);
2279
2280/**
2281 *      skb_zerocopy - Zero copy skb to skb
2282 *      @to: destination buffer
2283 *      @from: source buffer
2284 *      @len: number of bytes to copy from source buffer
2285 *      @hlen: size of linear headroom in destination buffer
2286 *
2287 *      Copies up to `len` bytes from `from` to `to` by creating references
2288 *      to the frags in the source buffer.
2289 *
2290 *      The `hlen` as calculated by skb_zerocopy_headlen() specifies the
2291 *      headroom in the `to` buffer.
2292 *
2293 *      Return value:
2294 *      0: everything is OK
2295 *      -ENOMEM: couldn't orphan frags of @from due to lack of memory
2296 *      -EFAULT: skb_copy_bits() found some problem with skb geometry
2297 */
2298int
2299skb_zerocopy(struct sk_buff *to, struct sk_buff *from, int len, int hlen)
2300{
2301        int i, j = 0;
2302        int plen = 0; /* length of skb->head fragment */
2303        int ret;
2304        struct page *page;
2305        unsigned int offset;
2306
2307        BUG_ON(!from->head_frag && !hlen);
2308
2309        /* dont bother with small payloads */
2310        if (len <= skb_tailroom(to))
2311                return skb_copy_bits(from, 0, skb_put(to, len), len);
2312
2313        if (hlen) {
2314                ret = skb_copy_bits(from, 0, skb_put(to, hlen), hlen);
2315                if (unlikely(ret))
2316                        return ret;
2317                len -= hlen;
2318        } else {
2319                plen = min_t(int, skb_headlen(from), len);
2320                if (plen) {
2321                        page = virt_to_head_page(from->head);
2322                        offset = from->data - (unsigned char *)page_address(page);
2323                        __skb_fill_page_desc(to, 0, page, offset, plen);
2324                        get_page(page);
2325                        j = 1;
2326                        len -= plen;
2327                }
2328        }
2329
2330        to->truesize += len + plen;
2331        to->len += len + plen;
2332        to->data_len += len + plen;
2333
2334        if (unlikely(skb_orphan_frags(from, GFP_ATOMIC))) {
2335                skb_tx_error(from);
2336                return -ENOMEM;
2337        }
2338
2339        for (i = 0; i < skb_shinfo(from)->nr_frags; i++) {
2340                if (!len)
2341                        break;
2342                skb_shinfo(to)->frags[j] = skb_shinfo(from)->frags[i];
2343                skb_shinfo(to)->frags[j].size = min_t(int, skb_shinfo(to)->frags[j].size, len);
2344                len -= skb_shinfo(to)->frags[j].size;
2345                skb_frag_ref(to, j);
2346                j++;
2347        }
2348        skb_shinfo(to)->nr_frags = j;
2349
2350        return 0;
2351}
2352EXPORT_SYMBOL_GPL(skb_zerocopy);
2353
2354void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to)
2355{
2356        __wsum csum;
2357        long csstart;
2358
2359        if (skb->ip_summed == CHECKSUM_PARTIAL)
2360                csstart = skb_checksum_start_offset(skb);
2361        else
2362                csstart = skb_headlen(skb);
2363
2364        BUG_ON(csstart > skb_headlen(skb));
2365
2366        skb_copy_from_linear_data(skb, to, csstart);
2367
2368        csum = 0;
2369        if (csstart != skb->len)
2370                csum = skb_copy_and_csum_bits(skb, csstart, to + csstart,
2371                                              skb->len - csstart, 0);
2372
2373        if (skb->ip_summed == CHECKSUM_PARTIAL) {
2374                long csstuff = csstart + skb->csum_offset;
2375
2376                *((__sum16 *)(to + csstuff)) = csum_fold(csum);
2377        }
2378}
2379EXPORT_SYMBOL(skb_copy_and_csum_dev);
2380
2381/**
2382 *      skb_dequeue - remove from the head of the queue
2383 *      @list: list to dequeue from
2384 *
2385 *      Remove the head of the list. The list lock is taken so the function
2386 *      may be used safely with other locking list functions. The head item is
2387 *      returned or %NULL if the list is empty.
2388 */
2389
2390struct sk_buff *skb_dequeue(struct sk_buff_head *list)
2391{
2392        unsigned long flags;
2393        struct sk_buff *result;
2394
2395        spin_lock_irqsave(&list->lock, flags);
2396        result = __skb_dequeue(list);
2397        spin_unlock_irqrestore(&list->lock, flags);
2398        return result;
2399}
2400EXPORT_SYMBOL(skb_dequeue);
2401
2402/**
2403 *      skb_dequeue_tail - remove from the tail of the queue
2404 *      @list: list to dequeue from
2405 *
2406 *      Remove the tail of the list. The list lock is taken so the function
2407 *      may be used safely with other locking list functions. The tail item is
2408 *      returned or %NULL if the list is empty.
2409 */
2410struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)
2411{
2412        unsigned long flags;
2413        struct sk_buff *result;
2414
2415        spin_lock_irqsave(&list->lock, flags);
2416        result = __skb_dequeue_tail(list);
2417        spin_unlock_irqrestore(&list->lock, flags);
2418        return result;
2419}
2420EXPORT_SYMBOL(skb_dequeue_tail);
2421
2422/**
2423 *      skb_queue_purge - empty a list
2424 *      @list: list to empty
2425 *
2426 *      Delete all buffers on an &sk_buff list. Each buffer is removed from
2427 *      the list and one reference dropped. This function takes the list
2428 *      lock and is atomic with respect to other list locking functions.
2429 */
2430void skb_queue_purge(struct sk_buff_head *list)
2431{
2432        struct sk_buff *skb;
2433        while ((skb = skb_dequeue(list)) != NULL)
2434                kfree_skb(skb);
2435}
2436EXPORT_SYMBOL(skb_queue_purge);
2437
2438/**
2439 *      skb_queue_head - queue a buffer at the list head
2440 *      @list: list to use
2441 *      @newsk: buffer to queue
2442 *
2443 *      Queue a buffer at the start of the list. This function takes the
2444 *      list lock and can be used safely with other locking &sk_buff functions
2445 *      safely.
2446 *
2447 *      A buffer cannot be placed on two lists at the same time.
2448 */
2449void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)
2450{
2451        unsigned long flags;
2452
2453        spin_lock_irqsave(&list->lock, flags);
2454        __skb_queue_head(list, newsk);
2455        spin_unlock_irqrestore(&list->lock, flags);
2456}
2457EXPORT_SYMBOL(skb_queue_head);
2458
2459/**
2460 *      skb_queue_tail - queue a buffer at the list tail
2461 *      @list: list to use
2462 *      @newsk: buffer to queue
2463 *
2464 *      Queue a buffer at the tail of the list. This function takes the
2465 *      list lock and can be used safely with other locking &sk_buff functions
2466 *      safely.
2467 *
2468 *      A buffer cannot be placed on two lists at the same time.
2469 */
2470void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
2471{
2472        unsigned long flags;
2473
2474        spin_lock_irqsave(&list->lock, flags);
2475        __skb_queue_tail(list, newsk);
2476        spin_unlock_irqrestore(&list->lock, flags);
2477}
2478EXPORT_SYMBOL(skb_queue_tail);
2479
2480/**
2481 *      skb_unlink      -       remove a buffer from a list
2482 *      @skb: buffer to remove
2483 *      @list: list to use
2484 *
2485 *      Remove a packet from a list. The list locks are taken and this
2486 *      function is atomic with respect to other list locked calls
2487 *
2488 *      You must know what list the SKB is on.
2489 */
2490void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
2491{
2492        unsigned long flags;
2493
2494        spin_lock_irqsave(&list->lock, flags);
2495        __skb_unlink(skb, list);
2496        spin_unlock_irqrestore(&list->lock, flags);
2497}
2498EXPORT_SYMBOL(skb_unlink);
2499
2500/**
2501 *      skb_append      -       append a buffer
2502 *      @old: buffer to insert after
2503 *      @newsk: buffer to insert
2504 *      @list: list to use
2505 *
2506 *      Place a packet after a given packet in a list. The list locks are taken
2507 *      and this function is atomic with respect to other list locked calls.
2508 *      A buffer cannot be placed on two lists at the same time.
2509 */
2510void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
2511{
2512        unsigned long flags;
2513
2514        spin_lock_irqsave(&list->lock, flags);
2515        __skb_queue_after(list, old, newsk);
2516        spin_unlock_irqrestore(&list->lock, flags);
2517}
2518EXPORT_SYMBOL(skb_append);
2519
2520/**
2521 *      skb_insert      -       insert a buffer
2522 *      @old: buffer to insert before
2523 *      @newsk: buffer to insert
2524 *      @list: list to use
2525 *
2526 *      Place a packet before a given packet in a list. The list locks are
2527 *      taken and this function is atomic with respect to other list locked
2528 *      calls.
2529 *
2530 *      A buffer cannot be placed on two lists at the same time.
2531 */
2532void skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)
2533{
2534        unsigned long flags;
2535
2536        spin_lock_irqsave(&list->lock, flags);
2537        __skb_insert(newsk, old->prev, old, list);
2538        spin_unlock_irqrestore(&list->lock, flags);
2539}
2540EXPORT_SYMBOL(skb_insert);
2541
2542static inline void skb_split_inside_header(struct sk_buff *skb,
2543                                           struct sk_buff* skb1,
2544                                           const u32 len, const int pos)
2545{
2546        int i;
2547
2548        skb_copy_from_linear_data_offset(skb, len, skb_put(skb1, pos - len),
2549                                         pos - len);
2550        /* And move data appendix as is. */
2551        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
2552                skb_shinfo(skb1)->frags[i] = skb_shinfo(skb)->frags[i];
2553
2554        skb_shinfo(skb1)->nr_frags = skb_shinfo(skb)->nr_frags;
2555        skb_shinfo(skb)->nr_frags  = 0;
2556        skb1->data_len             = skb->data_len;
2557        skb1->len                  += skb1->data_len;
2558        skb->data_len              = 0;
2559        skb->len                   = len;
2560        skb_set_tail_pointer(skb, len);
2561}
2562
2563static inline void skb_split_no_header(struct sk_buff *skb,
2564                                       struct sk_buff* skb1,
2565                                       const u32 len, int pos)
2566{
2567        int i, k = 0;
2568        const int nfrags = skb_shinfo(skb)->nr_frags;
2569
2570        skb_shinfo(skb)->nr_frags = 0;
2571        skb1->len                 = skb1->data_len = skb->len - len;
2572        skb->len                  = len;
2573        skb->data_len             = len - pos;
2574
2575        for (i = 0; i < nfrags; i++) {
2576                int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
2577
2578                if (pos + size > len) {
2579                        skb_shinfo(skb1)->frags[k] = skb_shinfo(skb)->frags[i];
2580
2581                        if (pos < len) {
2582                                /* Split frag.
2583                                 * We have two variants in this case:
2584                                 * 1. Move all the frag to the second
2585                                 *    part, if it is possible. F.e.
2586                                 *    this approach is mandatory for TUX,
2587                                 *    where splitting is expensive.
2588                                 * 2. Split is accurately. We make this.
2589                                 */
2590                                skb_frag_ref(skb, i);
2591                                skb_shinfo(skb1)->frags[0].page_offset += len - pos;
2592                                skb_frag_size_sub(&skb_shinfo(skb1)->frags[0], len - pos);
2593                                skb_frag_size_set(&skb_shinfo(skb)->frags[i], len - pos);
2594                                skb_shinfo(skb)->nr_frags++;
2595                        }
2596                        k++;
2597                } else
2598                        skb_shinfo(skb)->nr_frags++;
2599                pos += size;
2600        }
2601        skb_shinfo(skb1)->nr_frags = k;
2602}
2603
2604/**
2605 * skb_split - Split fragmented skb to two parts at length len.
2606 * @skb: the buffer to split
2607 * @skb1: the buffer to receive the second part
2608 * @len: new length for skb
2609 */
2610void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)
2611{
2612        int pos = skb_headlen(skb);
2613
2614        skb_shinfo(skb1)->tx_flags = skb_shinfo(skb)->tx_flags & SKBTX_SHARED_FRAG;
2615        if (len < pos)  /* Split line is inside header. */
2616                skb_split_inside_header(skb, skb1, len, pos);
2617        else            /* Second chunk has no header, nothing to copy. */
2618                skb_split_no_header(skb, skb1, len, pos);
2619}
2620EXPORT_SYMBOL(skb_split);
2621
2622/* Shifting from/to a cloned skb is a no-go.
2623 *
2624 * Caller cannot keep skb_shinfo related pointers past calling here!
2625 */
2626static int skb_prepare_for_shift(struct sk_buff *skb)
2627{
2628        return skb_cloned(skb) && pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2629}
2630
2631/**
2632 * skb_shift - Shifts paged data partially from skb to another
2633 * @tgt: buffer into which tail data gets added
2634 * @skb: buffer from which the paged data comes from
2635 * @shiftlen: shift up to this many bytes
2636 *
2637 * Attempts to shift up to shiftlen worth of bytes, which may be less than
2638 * the length of the skb, from skb to tgt. Returns number bytes shifted.
2639 * It's up to caller to free skb if everything was shifted.
2640 *
2641 * If @tgt runs out of frags, the whole operation is aborted.
2642 *
2643 * Skb cannot include anything else but paged data while tgt is allowed
2644 * to have non-paged data as well.
2645 *
2646 * TODO: full sized shift could be optimized but that would need
2647 * specialized skb free'er to handle frags without up-to-date nr_frags.
2648 */
2649int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen)
2650{
2651        int from, to, merge, todo;
2652        struct skb_frag_struct *fragfrom, *fragto;
2653
2654        BUG_ON(shiftlen > skb->len);
2655        BUG_ON(skb_headlen(skb));       /* Would corrupt stream */
2656
2657        todo = shiftlen;
2658        from = 0;
2659        to = skb_shinfo(tgt)->nr_frags;
2660        fragfrom = &skb_shinfo(skb)->frags[from];
2661
2662        /* Actual merge is delayed until the point when we know we can
2663         * commit all, so that we don't have to undo partial changes
2664         */
2665        if (!to ||
2666            !skb_can_coalesce(tgt, to, skb_frag_page(fragfrom),
2667                              fragfrom->page_offset)) {
2668                merge = -1;
2669        } else {
2670                merge = to - 1;
2671
2672                todo -= skb_frag_size(fragfrom);
2673                if (todo < 0) {
2674                        if (skb_prepare_for_shift(skb) ||
2675                            skb_prepare_for_shift(tgt))
2676                                return 0;
2677
2678                        /* All previous frag pointers might be stale! */
2679                        fragfrom = &skb_shinfo(skb)->frags[from];
2680                        fragto = &skb_shinfo(tgt)->frags[merge];
2681
2682                        skb_frag_size_add(fragto, shiftlen);
2683                        skb_frag_size_sub(fragfrom, shiftlen);
2684                        fragfrom->page_offset += shiftlen;
2685
2686                        goto onlymerged;
2687                }
2688
2689                from++;
2690        }
2691
2692        /* Skip full, not-fitting skb to avoid expensive operations */
2693        if ((shiftlen == skb->len) &&
2694            (skb_shinfo(skb)->nr_frags - from) > (MAX_SKB_FRAGS - to))
2695                return 0;
2696
2697        if (skb_prepare_for_shift(skb) || skb_prepare_for_shift(tgt))
2698                return 0;
2699
2700        while ((todo > 0) && (from < skb_shinfo(skb)->nr_frags)) {
2701                if (to == MAX_SKB_FRAGS)
2702                        return 0;
2703
2704                fragfrom = &skb_shinfo(skb)->frags[from];
2705                fragto = &skb_shinfo(tgt)->frags[to];
2706
2707                if (todo >= skb_frag_size(fragfrom)) {
2708                        *fragto = *fragfrom;
2709                        todo -= skb_frag_size(fragfrom);
2710                        from++;
2711                        to++;
2712
2713                } else {
2714                        __skb_frag_ref(fragfrom);
2715                        fragto->page = fragfrom->page;
2716                        fragto->page_offset = fragfrom->page_offset;
2717                        skb_frag_size_set(fragto, todo);
2718
2719                        fragfrom->page_offset += todo;
2720                        skb_frag_size_sub(fragfrom, todo);
2721                        todo = 0;
2722
2723                        to++;
2724                        break;
2725                }
2726        }
2727
2728        /* Ready to "commit" this state change to tgt */
2729        skb_shinfo(tgt)->nr_frags = to;
2730
2731        if (merge >= 0) {
2732                fragfrom = &skb_shinfo(skb)->frags[0];
2733                fragto = &skb_shinfo(tgt)->frags[merge];
2734
2735                skb_frag_size_add(fragto, skb_frag_size(fragfrom));
2736                __skb_frag_unref(fragfrom);
2737        }
2738
2739        /* Reposition in the original skb */
2740        to = 0;
2741        while (from < skb_shinfo(skb)->nr_frags)
2742                skb_shinfo(skb)->frags[to++] = skb_shinfo(skb)->frags[from++];
2743        skb_shinfo(skb)->nr_frags = to;
2744
2745        BUG_ON(todo > 0 && !skb_shinfo(skb)->nr_frags);
2746
2747onlymerged:
2748        /* Most likely the tgt won't ever need its checksum anymore, skb on
2749         * the other hand might need it if it needs to be resent
2750         */
2751        tgt->ip_summed = CHECKSUM_PARTIAL;
2752        skb->ip_summed = CHECKSUM_PARTIAL;
2753
2754        /* Yak, is it really working this way? Some helper please? */
2755        skb->len -= shiftlen;
2756        skb->data_len -= shiftlen;
2757        skb->truesize -= shiftlen;
2758        tgt->len += shiftlen;
2759        tgt->data_len += shiftlen;
2760        tgt->truesize += shiftlen;
2761
2762        return shiftlen;
2763}
2764
2765/**
2766 * skb_prepare_seq_read - Prepare a sequential read of skb data
2767 * @skb: the buffer to read
2768 * @from: lower offset of data to be read
2769 * @to: upper offset of data to be read
2770 * @st: state variable
2771 *
2772 * Initializes the specified state variable. Must be called before
2773 * invoking skb_seq_read() for the first time.
2774 */
2775void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
2776                          unsigned int to, struct skb_seq_state *st)
2777{
2778        st->lower_offset = from;
2779        st->upper_offset = to;
2780        st->root_skb = st->cur_skb = skb;
2781        st->frag_idx = st->stepped_offset = 0;
2782        st->frag_data = NULL;
2783}
2784EXPORT_SYMBOL(skb_prepare_seq_read);
2785
2786/**
2787 * skb_seq_read - Sequentially read skb data
2788 * @consumed: number of bytes consumed by the caller so far
2789 * @data: destination pointer for data to be returned
2790 * @st: state variable
2791 *
2792 * Reads a block of skb data at @consumed relative to the
2793 * lower offset specified to skb_prepare_seq_read(). Assigns
2794 * the head of the data block to @data and returns the length
2795 * of the block or 0 if the end of the skb data or the upper
2796 * offset has been reached.
2797 *
2798 * The caller is not required to consume all of the data
2799 * returned, i.e. @consumed is typically set to the number
2800 * of bytes already consumed and the next call to
2801 * skb_seq_read() will return the remaining part of the block.
2802 *
2803 * Note 1: The size of each block of data returned can be arbitrary,
2804 *       this limitation is the cost for zerocopy sequential
2805 *       reads of potentially non linear data.
2806 *
2807 * Note 2: Fragment lists within fragments are not implemented
2808 *       at the moment, state->root_skb could be replaced with
2809 *       a stack for this purpose.
2810 */
2811unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
2812                          struct skb_seq_state *st)
2813{
2814        unsigned int block_limit, abs_offset = consumed + st->lower_offset;
2815        skb_frag_t *frag;
2816
2817        if (unlikely(abs_offset >= st->upper_offset)) {
2818                if (st->frag_data) {
2819                        kunmap_atomic(st->frag_data);
2820                        st->frag_data = NULL;
2821                }
2822                return 0;
2823        }
2824
2825next_skb:
2826        block_limit = skb_headlen(st->cur_skb) + st->stepped_offset;
2827
2828        if (abs_offset < block_limit && !st->frag_data) {
2829                *data = st->cur_skb->data + (abs_offset - st->stepped_offset);
2830                return block_limit - abs_offset;
2831        }
2832
2833        if (st->frag_idx == 0 && !st->frag_data)
2834                st->stepped_offset += skb_headlen(st->cur_skb);
2835
2836        while (st->frag_idx < skb_shinfo(st->cur_skb)->nr_frags) {
2837                frag = &skb_shinfo(st->cur_skb)->frags[st->frag_idx];
2838                block_limit = skb_frag_size(frag) + st->stepped_offset;
2839
2840                if (abs_offset < block_limit) {
2841                        if (!st->frag_data)
2842                                st->frag_data = kmap_atomic(skb_frag_page(frag));
2843
2844                        *data = (u8 *) st->frag_data + frag->page_offset +
2845                                (abs_offset - st->stepped_offset);
2846
2847                        return block_limit - abs_offset;
2848                }
2849
2850                if (st->frag_data) {
2851                        kunmap_atomic(st->frag_data);
2852                        st->frag_data = NULL;
2853                }
2854
2855                st->frag_idx++;
2856                st->stepped_offset += skb_frag_size(frag);
2857        }
2858
2859        if (st->frag_data) {
2860                kunmap_atomic(st->frag_data);
2861                st->frag_data = NULL;
2862        }
2863
2864        if (st->root_skb == st->cur_skb && skb_has_frag_list(st->root_skb)) {
2865                st->cur_skb = skb_shinfo(st->root_skb)->frag_list;
2866                st->frag_idx = 0;
2867                goto next_skb;
2868        } else if (st->cur_skb->next) {
2869                st->cur_skb = st->cur_skb->next;
2870                st->frag_idx = 0;
2871                goto next_skb;
2872        }
2873
2874        return 0;
2875}
2876EXPORT_SYMBOL(skb_seq_read);
2877
2878/**
2879 * skb_abort_seq_read - Abort a sequential read of skb data
2880 * @st: state variable
2881 *
2882 * Must be called if skb_seq_read() was not called until it
2883 * returned 0.
2884 */
2885void skb_abort_seq_read(struct skb_seq_state *st)
2886{
2887        if (st->frag_data)
2888                kunmap_atomic(st->frag_data);
2889}
2890EXPORT_SYMBOL(skb_abort_seq_read);
2891
2892#define TS_SKB_CB(state)        ((struct skb_seq_state *) &((state)->cb))
2893
2894static unsigned int skb_ts_get_next_block(unsigned int offset, const u8 **text,
2895                                          struct ts_config *conf,
2896                                          struct ts_state *state)
2897{
2898        return skb_seq_read(offset, text, TS_SKB_CB(state));
2899}
2900
2901static void skb_ts_finish(struct ts_config *conf, struct ts_state *state)
2902{
2903        skb_abort_seq_read(TS_SKB_CB(state));
2904}
2905
2906/**
2907 * skb_find_text - Find a text pattern in skb data
2908 * @skb: the buffer to look in
2909 * @from: search offset
2910 * @to: search limit
2911 * @config: textsearch configuration
2912 * @state: uninitialized textsearch state variable
2913 *
2914 * Finds a pattern in the skb data according to the specified
2915 * textsearch configuration. Use textsearch_next() to retrieve
2916 * subsequent occurrences of the pattern. Returns the offset
2917 * to the first occurrence or UINT_MAX if no match was found.
2918 */
2919unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
2920                           unsigned int to, struct ts_config *config,
2921                           struct ts_state *state)
2922{
2923        unsigned int ret;
2924
2925        config->get_next_block = skb_ts_get_next_block;
2926        config->finish = skb_ts_finish;
2927
2928        skb_prepare_seq_read(skb, from, to, TS_SKB_CB(state));
2929
2930        ret = textsearch_find(config, state);
2931        return (ret <= to - from ? ret : UINT_MAX);
2932}
2933EXPORT_SYMBOL(skb_find_text);
2934
2935/**
2936 * skb_append_datato_frags - append the user data to a skb
2937 * @sk: sock  structure
2938 * @skb: skb structure to be appended with user data.
2939 * @getfrag: call back function to be used for getting the user data
2940 * @from: pointer to user message iov
2941 * @length: length of the iov message
2942 *
2943 * Description: This procedure append the user data in the fragment part
2944 * of the skb if any page alloc fails user this procedure returns  -ENOMEM
2945 */
2946int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
2947                        int (*getfrag)(void *from, char *to, int offset,
2948                                        int len, int odd, struct sk_buff *skb),
2949                        void *from, int length)
2950{
2951        int frg_cnt = skb_shinfo(skb)->nr_frags;
2952        int copy;
2953        int offset = 0;
2954        int ret;
2955        struct page_frag *pfrag = &current->task_frag;
2956
2957        do {
2958                /* Return error if we don't have space for new frag */
2959                if (frg_cnt >= MAX_SKB_FRAGS)
2960                        return -EMSGSIZE;
2961
2962                if (!sk_page_frag_refill(sk, pfrag))
2963                        return -ENOMEM;
2964
2965                /* copy the user data to page */
2966                copy = min_t(int, length, pfrag->size - pfrag->offset);
2967
2968                ret = getfrag(from, page_address(pfrag->page) + pfrag->offset,
2969                              offset, copy, 0, skb);
2970                if (ret < 0)
2971                        return -EFAULT;
2972
2973                /* copy was successful so update the size parameters */
2974                skb_fill_page_desc(skb, frg_cnt, pfrag->page, pfrag->offset,
2975                                   copy);
2976                frg_cnt++;
2977                pfrag->offset += copy;
2978                get_page(pfrag->page);
2979
2980                skb->truesize += copy;
2981                atomic_add(copy, &sk->sk_wmem_alloc);
2982                skb->len += copy;
2983                skb->data_len += copy;
2984                offset += copy;
2985                length -= copy;
2986
2987        } while (length > 0);
2988
2989        return 0;
2990}
2991EXPORT_SYMBOL(skb_append_datato_frags);
2992
2993/**
2994 *      skb_pull_rcsum - pull skb and update receive checksum
2995 *      @skb: buffer to update
2996 *      @len: length of data pulled
2997 *
2998 *      This function performs an skb_pull on the packet and updates
2999 *      the CHECKSUM_COMPLETE checksum.  It should be used on
3000 *      receive path processing instead of skb_pull unless you know
3001 *      that the checksum difference is zero (e.g., a valid IP header)
3002 *      or you are setting ip_summed to CHECKSUM_NONE.
3003 */
3004unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)
3005{
3006        unsigned char *data = skb->data;
3007
3008        BUG_ON(len > skb->len);
3009        __skb_pull(skb, len);
3010        skb_postpull_rcsum(skb, data, len);
3011        return skb->data;
3012}
3013EXPORT_SYMBOL_GPL(skb_pull_rcsum);
3014
3015/**
3016 *      skb_segment - Perform protocol segmentation on skb.
3017 *      @head_skb: buffer to segment
3018 *      @features: features for the output path (see dev->features)
3019 *
3020 *      This function performs segmentation on the given skb.  It returns
3021 *      a pointer to the first in a list of new skbs for the segments.
3022 *      In case of error it returns ERR_PTR(err).
3023 */
3024struct sk_buff *skb_segment(struct sk_buff *head_skb,
3025                            netdev_features_t features)
3026{
3027        struct sk_buff *segs = NULL;
3028        struct sk_buff *tail = NULL;
3029        struct sk_buff *list_skb = skb_shinfo(head_skb)->frag_list;
3030        skb_frag_t *frag = skb_shinfo(head_skb)->frags;
3031        unsigned int mss = skb_shinfo(head_skb)->gso_size;
3032        unsigned int doffset = head_skb->data - skb_mac_header(head_skb);
3033        struct sk_buff *frag_skb = head_skb;
3034        unsigned int offset = doffset;
3035        unsigned int tnl_hlen = skb_tnl_header_len(head_skb);
3036        unsigned int headroom;
3037        unsigned int len;
3038        __be16 proto;
3039        bool csum;
3040        int sg = !!(features & NETIF_F_SG);
3041        int nfrags = skb_shinfo(head_skb)->nr_frags;
3042        int err = -ENOMEM;
3043        int i = 0;
3044        int pos;
3045        int dummy;
3046
3047        __skb_push(head_skb, doffset);
3048        proto = skb_network_protocol(head_skb, &dummy);
3049        if (unlikely(!proto))
3050                return ERR_PTR(-EINVAL);
3051
3052        csum = !head_skb->encap_hdr_csum &&
3053            !!can_checksum_protocol(features, proto);
3054
3055        headroom = skb_headroom(head_skb);
3056        pos = skb_headlen(head_skb);
3057
3058        do {
3059                struct sk_buff *nskb;
3060                skb_frag_t *nskb_frag;
3061                int hsize;
3062                int size;
3063
3064                len = head_skb->len - offset;
3065                if (len > mss)
3066                        len = mss;
3067
3068                hsize = skb_headlen(head_skb) - offset;
3069                if (hsize < 0)
3070                        hsize = 0;
3071                if (hsize > len || !sg)
3072                        hsize = len;
3073
3074                if (!hsize && i >= nfrags && skb_headlen(list_skb) &&
3075                    (skb_headlen(list_skb) == len || sg)) {
3076                        BUG_ON(skb_headlen(list_skb) > len);
3077
3078                        i = 0;
3079                        nfrags = skb_shinfo(list_skb)->nr_frags;
3080                        frag = skb_shinfo(list_skb)->frags;
3081                        frag_skb = list_skb;
3082                        pos += skb_headlen(list_skb);
3083
3084                        while (pos < offset + len) {
3085                                BUG_ON(i >= nfrags);
3086
3087                                size = skb_frag_size(frag);
3088                                if (pos + size > offset + len)
3089                                        break;
3090
3091                                i++;
3092                                pos += size;
3093                                frag++;
3094                        }
3095
3096                        nskb = skb_clone(list_skb, GFP_ATOMIC);
3097                        list_skb = list_skb->next;
3098
3099                        if (unlikely(!nskb))
3100                                goto err;
3101
3102                        if (unlikely(pskb_trim(nskb, len))) {
3103                                kfree_skb(nskb);
3104                                goto err;
3105                        }
3106
3107                        hsize = skb_end_offset(nskb);
3108                        if (skb_cow_head(nskb, doffset + headroom)) {
3109                                kfree_skb(nskb);
3110                                goto err;
3111                        }
3112
3113                        nskb->truesize += skb_end_offset(nskb) - hsize;
3114                        skb_release_head_state(nskb);
3115                        __skb_push(nskb, doffset);
3116                } else {
3117                        nskb = __alloc_skb(hsize + doffset + headroom,
3118                                           GFP_ATOMIC, skb_alloc_rx_flag(head_skb),
3119                                           NUMA_NO_NODE);
3120
3121                        if (unlikely(!nskb))
3122                                goto err;
3123
3124                        skb_reserve(nskb, headroom);
3125                        __skb_put(nskb, doffset);
3126                }
3127
3128                if (segs)
3129                        tail->next = nskb;
3130                else
3131                        segs = nskb;
3132                tail = nskb;
3133
3134                __copy_skb_header(nskb, head_skb);
3135
3136                skb_headers_offset_update(nskb, skb_headroom(nskb) - headroom);
3137                skb_reset_mac_len(nskb);
3138
3139                skb_copy_from_linear_data_offset(head_skb, -tnl_hlen,
3140                                                 nskb->data - tnl_hlen,
3141                                                 doffset + tnl_hlen);
3142
3143                if (nskb->len == len + doffset)
3144                        goto perform_csum_check;
3145
3146                if (!sg) {
3147                        nskb->ip_summed = CHECKSUM_NONE;
3148                        nskb->csum = skb_copy_and_csum_bits(head_skb, offset,
3149                                                            skb_put(nskb, len),
3150                                                            len, 0);
3151                        SKB_GSO_CB(nskb)->csum_start =
3152                            skb_headroom(nskb) + doffset;
3153                        continue;
3154                }
3155
3156                nskb_frag = skb_shinfo(nskb)->frags;
3157
3158                skb_copy_from_linear_data_offset(head_skb, offset,
3159                                                 skb_put(nskb, hsize), hsize);
3160
3161                skb_shinfo(nskb)->tx_flags = skb_shinfo(head_skb)->tx_flags &
3162                        SKBTX_SHARED_FRAG;
3163
3164                while (pos < offset + len) {
3165                        if (i >= nfrags) {
3166                                BUG_ON(skb_headlen(list_skb));
3167
3168                                i = 0;
3169                                nfrags = skb_shinfo(list_skb)->nr_frags;
3170                                frag = skb_shinfo(list_skb)->frags;
3171                                frag_skb = list_skb;
3172
3173                                BUG_ON(!nfrags);
3174
3175                                list_skb = list_skb->next;
3176                        }
3177
3178                        if (unlikely(skb_shinfo(nskb)->nr_frags >=
3179                                     MAX_SKB_FRAGS)) {
3180                                net_warn_ratelimited(
3181                                        "skb_segment: too many frags: %u %u\n",
3182                                        pos, mss);
3183                                goto err;
3184                        }
3185
3186                        if (unlikely(skb_orphan_frags(frag_skb, GFP_ATOMIC)))
3187                                goto err;
3188
3189                        *nskb_frag = *frag;
3190                        __skb_frag_ref(nskb_frag);
3191                        size = skb_frag_size(nskb_frag);
3192
3193                        if (pos < offset) {
3194                                nskb_frag->page_offset += offset - pos;
3195                                skb_frag_size_sub(nskb_frag, offset - pos);
3196                        }
3197
3198                        skb_shinfo(nskb)->nr_frags++;
3199
3200                        if (pos + size <= offset + len) {
3201                                i++;
3202                                frag++;
3203                                pos += size;
3204                        } else {
3205                                skb_frag_size_sub(nskb_frag, pos + size - (offset + len));
3206                                goto skip_fraglist;
3207                        }
3208
3209                        nskb_frag++;
3210                }
3211
3212skip_fraglist:
3213                nskb->data_len = len - hsize;
3214                nskb->len += nskb->data_len;
3215                nskb->truesize += nskb->data_len;
3216
3217perform_csum_check:
3218                if (!csum) {
3219                        nskb->csum = skb_checksum(nskb, doffset,
3220                                                  nskb->len - doffset, 0);
3221                        nskb->ip_summed = CHECKSUM_NONE;
3222                        SKB_GSO_CB(nskb)->csum_start =
3223                            skb_headroom(nskb) + doffset;
3224                }
3225        } while ((offset += len) < head_skb->len);
3226
3227        /* Some callers want to get the end of the list.
3228         * Put it in segs->prev to avoid walking the list.
3229         * (see validate_xmit_skb_list() for example)
3230         */
3231        segs->prev = tail;
3232        return segs;
3233
3234err:
3235        kfree_skb_list(segs);
3236        return ERR_PTR(err);
3237}
3238EXPORT_SYMBOL_GPL(skb_segment);
3239
3240int BCMFASTPATH_HOST skb_gro_receive(struct sk_buff **head, struct sk_buff *skb)
3241{
3242        struct skb_shared_info *pinfo, *skbinfo = skb_shinfo(skb);
3243        unsigned int offset = skb_gro_offset(skb);
3244        unsigned int headlen = skb_headlen(skb);
3245        struct sk_buff *nskb, *lp, *p = *head;
3246        unsigned int len = skb_gro_len(skb);
3247        unsigned int delta_truesize;
3248        unsigned int headroom;
3249
3250        if (unlikely(p->len + len >= 65536))
3251                return -E2BIG;
3252
3253        lp = NAPI_GRO_CB(p)->last;
3254        pinfo = skb_shinfo(lp);
3255
3256        if (headlen <= offset) {
3257                skb_frag_t *frag;
3258                skb_frag_t *frag2;
3259                int i = skbinfo->nr_frags;
3260                int nr_frags = pinfo->nr_frags + i;
3261
3262                if (nr_frags > MAX_SKB_FRAGS)
3263                        goto merge;
3264
3265                offset -= headlen;
3266                pinfo->nr_frags = nr_frags;
3267                skbinfo->nr_frags = 0;
3268
3269                frag = pinfo->frags + nr_frags;
3270                frag2 = skbinfo->frags + i;
3271                do {
3272                        *--frag = *--frag2;
3273                } while (--i);
3274
3275                frag->page_offset += offset;
3276                skb_frag_size_sub(frag, offset);
3277
3278                /* all fragments truesize : remove (head size + sk_buff) */
3279                delta_truesize = skb->truesize -
3280                                 SKB_TRUESIZE(skb_end_offset(skb));
3281
3282                skb->truesize -= skb->data_len;
3283                skb->len -= skb->data_len;
3284                skb->data_len = 0;
3285
3286                NAPI_GRO_CB(skb)->free = NAPI_GRO_FREE;
3287                goto done;
3288        } else if (skb->head_frag) {
3289                int nr_frags = pinfo->nr_frags;
3290                skb_frag_t *frag = pinfo->frags + nr_frags;
3291                struct page *page = virt_to_head_page(skb->head);
3292                unsigned int first_size = headlen - offset;
3293                unsigned int first_offset;
3294
3295                if (nr_frags + 1 + skbinfo->nr_frags > MAX_SKB_FRAGS)
3296                        goto merge;
3297
3298                first_offset = skb->data -
3299                               (unsigned char *)page_address(page) +
3300                               offset;
3301
3302                pinfo->nr_frags = nr_frags + 1 + skbinfo->nr_frags;
3303
3304                frag->page.p      = page;
3305                frag->page_offset = first_offset;
3306                skb_frag_size_set(frag, first_size);
3307
3308                memcpy(frag + 1, skbinfo->frags, sizeof(*frag) * skbinfo->nr_frags);
3309                /* We dont need to clear skbinfo->nr_frags here */
3310
3311                delta_truesize = skb->truesize - SKB_DATA_ALIGN(sizeof(struct sk_buff));
3312                NAPI_GRO_CB(skb)->free = NAPI_GRO_FREE_STOLEN_HEAD;
3313                goto done;
3314        }
3315        /* switch back to head shinfo */
3316        pinfo = skb_shinfo(p);
3317
3318        if (pinfo->frag_list)
3319                goto merge;
3320        if (skb_gro_len(p) != pinfo->gso_size)
3321                return -E2BIG;
3322
3323        headroom = skb_headroom(p);
3324        nskb = alloc_skb(headroom + skb_gro_offset(p), GFP_ATOMIC);
3325        if (unlikely(!nskb))
3326                return -ENOMEM;
3327
3328        __copy_skb_header(nskb, p);
3329        nskb->mac_len = p->mac_len;
3330
3331        skb_reserve(nskb, headroom);
3332        __skb_put(nskb, skb_gro_offset(p));
3333
3334        skb_set_mac_header(nskb, skb_mac_header(p) - p->data);
3335        skb_set_network_header(nskb, skb_network_offset(p));
3336        skb_set_transport_header(nskb, skb_transport_offset(p));
3337
3338        __skb_pull(p, skb_gro_offset(p));
3339        memcpy(skb_mac_header(nskb), skb_mac_header(p),
3340               p->data - skb_mac_header(p));
3341
3342        skb_shinfo(nskb)->frag_list = p;
3343        skb_shinfo(nskb)->gso_size = pinfo->gso_size;
3344        pinfo->gso_size = 0;
3345        __skb_header_release(p);
3346        NAPI_GRO_CB(nskb)->last = p;
3347
3348        nskb->data_len += p->len;
3349        nskb->truesize += p->truesize;
3350        nskb->len += p->len;
3351
3352        *head = nskb;
3353        nskb->next = p->next;
3354        p->next = NULL;
3355
3356        p = nskb;
3357
3358merge:
3359        delta_truesize = skb->truesize;
3360        if (offset > headlen) {
3361                unsigned int eat = offset - headlen;
3362
3363                skbinfo->frags[0].page_offset += eat;
3364                skb_frag_size_sub(&skbinfo->frags[0], eat);
3365                skb->data_len -= eat;
3366                skb->len -= eat;
3367                offset = headlen;
3368        }
3369
3370        __skb_pull(skb, offset);
3371
3372        if (NAPI_GRO_CB(p)->last == p)
3373                skb_shinfo(p)->frag_list = skb;
3374        else
3375                NAPI_GRO_CB(p)->last->next = skb;
3376        NAPI_GRO_CB(p)->last = skb;
3377        __skb_header_release(skb);
3378        lp = p;
3379
3380done:
3381        NAPI_GRO_CB(p)->count++;
3382        p->data_len += len;
3383        p->truesize += delta_truesize;
3384        p->len += len;
3385        if (lp != p) {
3386                lp->data_len += len;
3387                lp->truesize += delta_truesize;
3388                lp->len += len;
3389        }
3390        NAPI_GRO_CB(skb)->same_flow = 1;
3391        return 0;
3392}
3393
3394void __init skb_init(void)
3395{
3396        skbuff_head_cache = kmem_cache_create("skbuff_head_cache",
3397                                              sizeof(struct sk_buff),
3398                                              0,
3399                                              SLAB_HWCACHE_ALIGN|SLAB_PANIC,
3400                                              NULL);
3401        skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
3402                                                sizeof(struct sk_buff_fclones),
3403                                                0,
3404                                                SLAB_HWCACHE_ALIGN|SLAB_PANIC,
3405                                                NULL);
3406#if defined(CONFIG_IMQ) || defined(CONFIG_IMQ_MODULE)
3407        skbuff_cb_store_cache = kmem_cache_create("skbuff_cb_store_cache",
3408                                                  sizeof(struct skb_cb_table),
3409                                                  0,
3410                                                  SLAB_HWCACHE_ALIGN|SLAB_PANIC,
3411                                                  NULL);
3412#endif
3413}
3414
3415/**
3416 *      skb_to_sgvec - Fill a scatter-gather list from a socket buffer
3417 *      @skb: Socket buffer containing the buffers to be mapped
3418 *      @sg: The scatter-gather list to map into
3419 *      @offset: The offset into the buffer's contents to start mapping
3420 *      @len: Length of buffer space to be mapped
3421 *
3422 *      Fill the specified scatter-gather list with mappings/pointers into a
3423 *      region of the buffer space attached to a socket buffer.
3424 */
3425static int
3426__skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
3427{
3428        int start = skb_headlen(skb);
3429        int i, copy = start - offset;
3430        struct sk_buff *frag_iter;
3431        int elt = 0;
3432
3433        if (copy > 0) {
3434                if (copy > len)
3435                        copy = len;
3436                sg_set_buf(sg, skb->data + offset, copy);
3437                elt++;
3438                if ((len -= copy) == 0)
3439                        return elt;
3440                offset += copy;
3441        }
3442
3443        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
3444                int end;
3445
3446                WARN_ON(start > offset + len);
3447
3448                end = start + skb_frag_size(&skb_shinfo(skb)->frags[i]);
3449                if ((copy = end - offset) > 0) {
3450                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
3451
3452                        if (copy > len)
3453                                copy = len;
3454                        sg_set_page(&sg[elt], skb_frag_page(frag), copy,
3455                                        frag->page_offset+offset-start);
3456                        elt++;
3457                        if (!(len -= copy))
3458                                return elt;
3459                        offset += copy;
3460                }
3461                start = end;
3462        }
3463
3464        skb_walk_frags(skb, frag_iter) {
3465                int end;
3466
3467                WARN_ON(start > offset + len);
3468
3469                end = start + frag_iter->len;
3470                if ((copy = end - offset) > 0) {
3471                        if (copy > len)
3472                                copy = len;
3473                        elt += __skb_to_sgvec(frag_iter, sg+elt, offset - start,
3474                                              copy);
3475                        if ((len -= copy) == 0)
3476                                return elt;
3477                        offset += copy;
3478                }
3479                start = end;
3480        }
3481        BUG_ON(len);
3482        return elt;
3483}
3484
3485/* As compared with skb_to_sgvec, skb_to_sgvec_nomark only map skb to given
3486 * sglist without mark the sg which contain last skb data as the end.
3487 * So the caller can mannipulate sg list as will when padding new data after
3488 * the first call without calling sg_unmark_end to expend sg list.
3489 *
3490 * Scenario to use skb_to_sgvec_nomark:
3491 * 1. sg_init_table
3492 * 2. skb_to_sgvec_nomark(payload1)
3493 * 3. skb_to_sgvec_nomark(payload2)
3494 *
3495 * This is equivalent to:
3496 * 1. sg_init_table
3497 * 2. skb_to_sgvec(payload1)
3498 * 3. sg_unmark_end
3499 * 4. skb_to_sgvec(payload2)
3500 *
3501 * When mapping mutilple payload conditionally, skb_to_sgvec_nomark
3502 * is more preferable.
3503 */
3504int skb_to_sgvec_nomark(struct sk_buff *skb, struct scatterlist *sg,
3505                        int offset, int len)
3506{
3507        return __skb_to_sgvec(skb, sg, offset, len);
3508}
3509EXPORT_SYMBOL_GPL(skb_to_sgvec_nomark);
3510
3511int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
3512{
3513        int nsg = __skb_to_sgvec(skb, sg, offset, len);
3514
3515        sg_mark_end(&sg[nsg - 1]);
3516
3517        return nsg;
3518}
3519EXPORT_SYMBOL_GPL(skb_to_sgvec);
3520
3521/**
3522 *      skb_cow_data - Check that a socket buffer's data buffers are writable
3523 *      @skb: The socket buffer to check.
3524 *      @tailbits: Amount of trailing space to be added
3525 *      @trailer: Returned pointer to the skb where the @tailbits space begins
3526 *
3527 *      Make sure that the data buffers attached to a socket buffer are
3528 *      writable. If they are not, private copies are made of the data buffers
3529 *      and the socket buffer is set to use these instead.
3530 *
3531 *      If @tailbits is given, make sure that there is space to write @tailbits
3532 *      bytes of data beyond current end of socket buffer.  @trailer will be
3533 *      set to point to the skb in which this space begins.
3534 *
3535 *      The number of scatterlist elements required to completely map the
3536 *      COW'd and extended socket buffer will be returned.
3537 */
3538int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
3539{
3540        int copyflag;
3541        int elt;
3542        struct sk_buff *skb1, **skb_p;
3543
3544        /* If skb is cloned or its head is paged, reallocate
3545         * head pulling out all the pages (pages are considered not writable
3546         * at the moment even if they are anonymous).
3547         */
3548        if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) &&
3549            __pskb_pull_tail(skb, skb_pagelen(skb)-skb_headlen(skb)) == NULL)
3550                return -ENOMEM;
3551
3552        /* Easy case. Most of packets will go this way. */
3553        if (!skb_has_frag_list(skb)) {
3554                /* A little of trouble, not enough of space for trailer.
3555                 * This should not happen, when stack is tuned to generate
3556                 * good frames. OK, on miss we reallocate and reserve even more
3557                 * space, 128 bytes is fair. */
3558
3559                if (skb_tailroom(skb) < tailbits &&
3560                    pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC))
3561                        return -ENOMEM;
3562
3563                /* Voila! */
3564                *trailer = skb;
3565                return 1;
3566        }
3567
3568        /* Misery. We are in troubles, going to mincer fragments... */
3569
3570        elt = 1;
3571        skb_p = &skb_shinfo(skb)->frag_list;
3572        copyflag = 0;
3573
3574        while ((skb1 = *skb_p) != NULL) {
3575                int ntail = 0;
3576
3577                /* The fragment is partially pulled by someone,
3578                 * this can happen on input. Copy it and everything
3579                 * after it. */
3580
3581                if (skb_shared(skb1))
3582                        copyflag = 1;
3583
3584                /* If the skb is the last, worry about trailer. */
3585
3586                if (skb1->next == NULL && tailbits) {
3587                        if (skb_shinfo(skb1)->nr_frags ||
3588                            skb_has_frag_list(skb1) ||
3589                            skb_tailroom(skb1) < tailbits)
3590                                ntail = tailbits + 128;
3591                }
3592
3593                if (copyflag ||
3594                    skb_cloned(skb1) ||
3595                    ntail ||
3596                    skb_shinfo(skb1)->nr_frags ||
3597                    skb_has_frag_list(skb1)) {
3598                        struct sk_buff *skb2;
3599
3600                        /* Fuck, we are miserable poor guys... */
3601                        if (ntail == 0)
3602                                skb2 = skb_copy(skb1, GFP_ATOMIC);
3603                        else
3604                                skb2 = skb_copy_expand(skb1,
3605                                                       skb_headroom(skb1),
3606                                                       ntail,
3607                                                       GFP_ATOMIC);
3608                        if (unlikely(skb2 == NULL))
3609                                return -ENOMEM;
3610
3611                        if (skb1->sk)
3612                                skb_set_owner_w(skb2, skb1->sk);
3613
3614                        /* Looking around. Are we still alive?
3615                         * OK, link new skb, drop old one */
3616
3617                        skb2->next = skb1->next;
3618                        *skb_p = skb2;
3619                        kfree_skb(skb1);
3620                        skb1 = skb2;
3621                }
3622                elt++;
3623                *trailer = skb1;
3624                skb_p = &skb1->next;
3625        }
3626
3627        return elt;
3628}
3629EXPORT_SYMBOL_GPL(skb_cow_data);
3630
3631static void sock_rmem_free(struct sk_buff *skb)
3632{
3633        struct sock *sk = skb->sk;
3634
3635        atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
3636}
3637
3638/*
3639 * Note: We dont mem charge error packets (no sk_forward_alloc changes)
3640 */
3641int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
3642{
3643        if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
3644            (unsigned int)sk->sk_rcvbuf)
3645                return -ENOMEM;
3646
3647        skb_orphan(skb);
3648        skb->sk = sk;
3649        skb->destructor = sock_rmem_free;
3650        atomic_add(skb->truesize, &sk->sk_rmem_alloc);
3651
3652        /* before exiting rcu section, make sure dst is refcounted */
3653        skb_dst_force(skb);
3654
3655        skb_queue_tail(&sk->sk_error_queue, skb);
3656        if (!sock_flag(sk, SOCK_DEAD))
3657                sk->sk_data_ready(sk);
3658        return 0;
3659}
3660EXPORT_SYMBOL(sock_queue_err_skb);
3661
3662struct sk_buff *sock_dequeue_err_skb(struct sock *sk)
3663{
3664        struct sk_buff_head *q = &sk->sk_error_queue;
3665        struct sk_buff *skb, *skb_next;
3666        unsigned long flags;
3667        int err = 0;
3668
3669        spin_lock_irqsave(&q->lock, flags);
3670        skb = __skb_dequeue(q);
3671        if (skb && (skb_next = skb_peek(q)))
3672                err = SKB_EXT_ERR(skb_next)->ee.ee_errno;
3673        spin_unlock_irqrestore(&q->lock, flags);
3674
3675        sk->sk_err = err;
3676        if (err)
3677                sk->sk_error_report(sk);
3678
3679        return skb;
3680}
3681EXPORT_SYMBOL(sock_dequeue_err_skb);
3682
3683/**
3684 * skb_clone_sk - create clone of skb, and take reference to socket
3685 * @skb: the skb to clone
3686 *
3687 * This function creates a clone of a buffer that holds a reference on
3688 * sk_refcnt.  Buffers created via this function are meant to be
3689 * returned using sock_queue_err_skb, or free via kfree_skb.
3690 *
3691 * When passing buffers allocated with this function to sock_queue_err_skb
3692 * it is necessary to wrap the call with sock_hold/sock_put in order to
3693 * prevent the socket from being released prior to being enqueued on
3694 * the sk_error_queue.
3695 */
3696struct sk_buff *skb_clone_sk(struct sk_buff *skb)
3697{
3698        struct sock *sk = skb->sk;
3699        struct sk_buff *clone;
3700
3701        if (!sk || !atomic_inc_not_zero(&sk->sk_refcnt))
3702                return NULL;
3703
3704        clone = skb_clone(skb, GFP_ATOMIC);
3705        if (!clone) {
3706                sock_put(sk);
3707                return NULL;
3708        }
3709
3710        clone->sk = sk;
3711        clone->destructor = sock_efree;
3712
3713        return clone;
3714}
3715EXPORT_SYMBOL(skb_clone_sk);
3716
3717static void __skb_complete_tx_timestamp(struct sk_buff *skb,
3718                                        struct sock *sk,
3719                                        int tstype)
3720{
3721        struct sock_exterr_skb *serr;
3722        int err;
3723
3724        serr = SKB_EXT_ERR(skb);
3725        memset(serr, 0, sizeof(*serr));
3726        serr->ee.ee_errno = ENOMSG;
3727        serr->ee.ee_origin = SO_EE_ORIGIN_TIMESTAMPING;
3728        serr->ee.ee_info = tstype;
3729        if (sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID) {
3730                serr->ee.ee_data = skb_shinfo(skb)->tskey;
3731                if (sk->sk_protocol == IPPROTO_TCP &&
3732                    sk->sk_type == SOCK_STREAM)
3733                        serr->ee.ee_data -= sk->sk_tskey;
3734        }
3735
3736        err = sock_queue_err_skb(sk, skb);
3737
3738        if (err)
3739                kfree_skb(skb);
3740}
3741
3742void skb_complete_tx_timestamp(struct sk_buff *skb,
3743                               struct skb_shared_hwtstamps *hwtstamps)
3744{
3745        struct sock *sk = skb->sk;
3746
3747        /* Take a reference to prevent skb_orphan() from freeing the socket,
3748         * but only if the socket refcount is not zero.
3749         */
3750        if (likely(atomic_inc_not_zero(&sk->sk_refcnt))) {
3751                *skb_hwtstamps(skb) = *hwtstamps;
3752                __skb_complete_tx_timestamp(skb, sk, SCM_TSTAMP_SND);
3753                sock_put(sk);
3754        }
3755}
3756EXPORT_SYMBOL_GPL(skb_complete_tx_timestamp);
3757
3758void __skb_tstamp_tx(struct sk_buff *orig_skb,
3759                     struct skb_shared_hwtstamps *hwtstamps,
3760                     struct sock *sk, int tstype)
3761{
3762        struct sk_buff *skb;
3763
3764        if (!sk)
3765                return;
3766
3767        if (hwtstamps)
3768                *skb_hwtstamps(orig_skb) = *hwtstamps;
3769        else
3770                orig_skb->tstamp = ktime_get_real();
3771
3772        skb = skb_clone(orig_skb, GFP_ATOMIC);
3773        if (!skb)
3774                return;
3775
3776        __skb_complete_tx_timestamp(skb, sk, tstype);
3777}
3778EXPORT_SYMBOL_GPL(__skb_tstamp_tx);
3779
3780void skb_tstamp_tx(struct sk_buff *orig_skb,
3781                   struct skb_shared_hwtstamps *hwtstamps)
3782{
3783        return __skb_tstamp_tx(orig_skb, hwtstamps, orig_skb->sk,
3784                               SCM_TSTAMP_SND);
3785}
3786EXPORT_SYMBOL_GPL(skb_tstamp_tx);
3787
3788void skb_complete_wifi_ack(struct sk_buff *skb, bool acked)
3789{
3790        struct sock *sk = skb->sk;
3791        struct sock_exterr_skb *serr;
3792        int err = 1;
3793
3794        skb->wifi_acked_valid = 1;
3795        skb->wifi_acked = acked;
3796
3797        serr = SKB_EXT_ERR(skb);
3798        memset(serr, 0, sizeof(*serr));
3799        serr->ee.ee_errno = ENOMSG;
3800        serr->ee.ee_origin = SO_EE_ORIGIN_TXSTATUS;
3801
3802        /* Take a reference to prevent skb_orphan() from freeing the socket,
3803         * but only if the socket refcount is not zero.
3804         */
3805        if (likely(atomic_inc_not_zero(&sk->sk_refcnt))) {
3806                err = sock_queue_err_skb(sk, skb);
3807                sock_put(sk);
3808        }
3809        if (err)
3810                kfree_skb(skb);
3811}
3812EXPORT_SYMBOL_GPL(skb_complete_wifi_ack);
3813
3814
3815/**
3816 * skb_partial_csum_set - set up and verify partial csum values for packet
3817 * @skb: the skb to set
3818 * @start: the number of bytes after skb->data to start checksumming.
3819 * @off: the offset from start to place the checksum.
3820 *
3821 * For untrusted partially-checksummed packets, we need to make sure the values
3822 * for skb->csum_start and skb->csum_offset are valid so we don't oops.
3823 *
3824 * This function checks and sets those values and skb->ip_summed: if this
3825 * returns false you should drop the packet.
3826 */
3827bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)
3828{
3829        if (unlikely(start > skb_headlen(skb)) ||
3830            unlikely((int)start + off > skb_headlen(skb) - 2)) {
3831                net_warn_ratelimited("bad partial csum: csum=%u/%u len=%u\n",
3832                                     start, off, skb_headlen(skb));
3833                return false;
3834        }
3835        skb->ip_summed = CHECKSUM_PARTIAL;
3836        skb->csum_start = skb_headroom(skb) + start;
3837        skb->csum_offset = off;
3838        skb_set_transport_header(skb, start);
3839        return true;
3840}
3841EXPORT_SYMBOL_GPL(skb_partial_csum_set);
3842
3843static int skb_maybe_pull_tail(struct sk_buff *skb, unsigned int len,
3844                               unsigned int max)
3845{
3846        if (skb_headlen(skb) >= len)
3847                return 0;
3848
3849        /* If we need to pullup then pullup to the max, so we
3850         * won't need to do it again.
3851         */
3852        if (max > skb->len)
3853                max = skb->len;
3854
3855        if (__pskb_pull_tail(skb, max - skb_headlen(skb)) == NULL)
3856                return -ENOMEM;
3857
3858        if (skb_headlen(skb) < len)
3859                return -EPROTO;
3860
3861        return 0;
3862}
3863
3864#define MAX_TCP_HDR_LEN (15 * 4)
3865
3866static __sum16 *skb_checksum_setup_ip(struct sk_buff *skb,
3867                                      typeof(IPPROTO_IP) proto,
3868                                      unsigned int off)
3869{
3870        switch (proto) {
3871                int err;
3872
3873        case IPPROTO_TCP:
3874                err = skb_maybe_pull_tail(skb, off + sizeof(struct tcphdr),
3875                                          off + MAX_TCP_HDR_LEN);
3876                if (!err && !skb_partial_csum_set(skb, off,
3877                                                  offsetof(struct tcphdr,
3878                                                           check)))
3879                        err = -EPROTO;
3880                return err ? ERR_PTR(err) : &tcp_hdr(skb)->check;
3881
3882        case IPPROTO_UDP:
3883                err = skb_maybe_pull_tail(skb, off + sizeof(struct udphdr),
3884                                          off + sizeof(struct udphdr));
3885                if (!err && !skb_partial_csum_set(skb, off,
3886                                                  offsetof(struct udphdr,
3887                                                           check)))
3888                        err = -EPROTO;
3889                return err ? ERR_PTR(err) : &udp_hdr(skb)->check;
3890        }
3891
3892        return ERR_PTR(-EPROTO);
3893}
3894
3895/* This value should be large enough to cover a tagged ethernet header plus
3896 * maximally sized IP and TCP or UDP headers.
3897 */
3898#define MAX_IP_HDR_LEN 128
3899
3900static int skb_checksum_setup_ipv4(struct sk_buff *skb, bool recalculate)
3901{
3902        unsigned int off;
3903        bool fragment;
3904        __sum16 *csum;
3905        int err;
3906
3907        fragment = false;
3908
3909        err = skb_maybe_pull_tail(skb,
3910                                  sizeof(struct iphdr),
3911                                  MAX_IP_HDR_LEN);
3912        if (err < 0)
3913                goto out;
3914
3915        if (ip_hdr(skb)->frag_off & htons(IP_OFFSET | IP_MF))
3916                fragment = true;
3917
3918        off = ip_hdrlen(skb);
3919
3920        err = -EPROTO;
3921
3922        if (fragment)
3923                goto out;
3924
3925        csum = skb_checksum_setup_ip(skb, ip_hdr(skb)->protocol, off);
3926        if (IS_ERR(csum))
3927                return PTR_ERR(csum);
3928
3929        if (recalculate)
3930                *csum = ~csum_tcpudp_magic(ip_hdr(skb)->saddr,
3931                                           ip_hdr(skb)->daddr,
3932                                           skb->len - off,
3933                                           ip_hdr(skb)->protocol, 0);
3934        err = 0;
3935
3936out:
3937        return err;
3938}
3939
3940/* This value should be large enough to cover a tagged ethernet header plus
3941 * an IPv6 header, all options, and a maximal TCP or UDP header.
3942 */
3943#define MAX_IPV6_HDR_LEN 256
3944
3945#define OPT_HDR(type, skb, off) \
3946        (type *)(skb_network_header(skb) + (off))
3947
3948static int skb_checksum_setup_ipv6(struct sk_buff *skb, bool recalculate)
3949{
3950        int err;
3951        u8 nexthdr;
3952        unsigned int off;
3953        unsigned int len;
3954        bool fragment;
3955        bool done;
3956        __sum16 *csum;
3957
3958        fragment = false;
3959        done = false;
3960
3961        off = sizeof(struct ipv6hdr);
3962
3963        err = skb_maybe_pull_tail(skb, off, MAX_IPV6_HDR_LEN);
3964        if (err < 0)
3965                goto out;
3966
3967        nexthdr = ipv6_hdr(skb)->nexthdr;
3968
3969        len = sizeof(struct ipv6hdr) + ntohs(ipv6_hdr(skb)->payload_len);
3970        while (off <= len && !done) {
3971                switch (nexthdr) {
3972                case IPPROTO_DSTOPTS:
3973                case IPPROTO_HOPOPTS:
3974                case IPPROTO_ROUTING: {
3975                        struct ipv6_opt_hdr *hp;
3976
3977                        err = skb_maybe_pull_tail(skb,
3978                                                  off +
3979                                                  sizeof(struct ipv6_opt_hdr),
3980                                                  MAX_IPV6_HDR_LEN);
3981                        if (err < 0)
3982                                goto out;
3983
3984                        hp = OPT_HDR(struct ipv6_opt_hdr, skb, off);
3985                        nexthdr = hp->nexthdr;
3986                        off += ipv6_optlen(hp);
3987                        break;
3988                }
3989                case IPPROTO_AH: {
3990                        struct ip_auth_hdr *hp;
3991
3992                        err = skb_maybe_pull_tail(skb,
3993                                                  off +
3994                                                  sizeof(struct ip_auth_hdr),
3995                                                  MAX_IPV6_HDR_LEN);
3996                        if (err < 0)
3997                                goto out;
3998
3999                        hp = OPT_HDR(struct ip_auth_hdr, skb, off);
4000                        nexthdr = hp->nexthdr;
4001                        off += ipv6_authlen(hp);
4002                        break;
4003                }
4004                case IPPROTO_FRAGMENT: {
4005                        struct frag_hdr *hp;
4006
4007                        err = skb_maybe_pull_tail(skb,
4008                                                  off +
4009                                                  sizeof(struct frag_hdr),
4010                                                  MAX_IPV6_HDR_LEN);
4011                        if (err < 0)
4012                                goto out;
4013
4014                        hp = OPT_HDR(struct frag_hdr, skb, off);
4015
4016                        if (hp->frag_off & htons(IP6_OFFSET | IP6_MF))
4017                                fragment = true;
4018
4019                        nexthdr = hp->nexthdr;
4020                        off += sizeof(struct frag_hdr);
4021                        break;
4022                }
4023                default:
4024                        done = true;
4025                        break;
4026                }
4027        }
4028
4029        err = -EPROTO;
4030
4031        if (!done || fragment)
4032                goto out;
4033
4034        csum = skb_checksum_setup_ip(skb, nexthdr, off);
4035        if (IS_ERR(csum))
4036                return PTR_ERR(csum);
4037
4038        if (recalculate)
4039                *csum = ~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
4040                                         &ipv6_hdr(skb)->daddr,
4041                                         skb->len - off, nexthdr, 0);
4042        err = 0;
4043
4044out:
4045        return err;
4046}
4047
4048/**
4049 * skb_checksum_setup - set up partial checksum offset
4050 * @skb: the skb to set up
4051 * @recalculate: if true the pseudo-header checksum will be recalculated
4052 */
4053int skb_checksum_setup(struct sk_buff *skb, bool recalculate)
4054{
4055        int err;
4056
4057        switch (skb->protocol) {
4058        case htons(ETH_P_IP):
4059                err = skb_checksum_setup_ipv4(skb, recalculate);
4060                break;
4061
4062        case htons(ETH_P_IPV6):
4063                err = skb_checksum_setup_ipv6(skb, recalculate);
4064                break;
4065
4066        default:
4067                err = -EPROTO;
4068                break;
4069        }
4070
4071        return err;
4072}
4073EXPORT_SYMBOL(skb_checksum_setup);
4074
4075void __skb_warn_lro_forwarding(const struct sk_buff *skb)
4076{
4077        net_warn_ratelimited("%s: received packets cannot be forwarded while LRO is enabled\n",
4078                             skb->dev->name);
4079}
4080EXPORT_SYMBOL(__skb_warn_lro_forwarding);
4081
4082void kfree_skb_partial(struct sk_buff *skb, bool head_stolen)
4083{
4084        if (head_stolen) {
4085                skb_release_head_state(skb);
4086                kmem_cache_free(skbuff_head_cache, skb);
4087        } else {
4088                __kfree_skb(skb);
4089        }
4090}
4091EXPORT_SYMBOL(kfree_skb_partial);
4092
4093/**
4094 * skb_try_coalesce - try to merge skb to prior one
4095 * @to: prior buffer
4096 * @from: buffer to add
4097 * @fragstolen: pointer to boolean
4098 * @delta_truesize: how much more was allocated than was requested
4099 */
4100bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
4101                      bool *fragstolen, int *delta_truesize)
4102{
4103        int i, delta, len = from->len;
4104
4105        *fragstolen = false;
4106
4107        if (skb_cloned(to))
4108                return false;
4109
4110        if (len <= skb_tailroom(to)) {
4111                if (len)
4112                        BUG_ON(skb_copy_bits(from, 0, skb_put(to, len), len));
4113                *delta_truesize = 0;
4114                return true;
4115        }
4116
4117        if (skb_has_frag_list(to) || skb_has_frag_list(from))
4118                return false;
4119
4120        if (skb_headlen(from) != 0) {
4121                struct page *page;
4122                unsigned int offset;
4123
4124                if (skb_shinfo(to)->nr_frags +
4125                    skb_shinfo(from)->nr_frags >= MAX_SKB_FRAGS)
4126                        return false;
4127
4128                if (skb_head_is_locked(from))
4129                        return false;
4130
4131                delta = from->truesize - SKB_DATA_ALIGN(sizeof(struct sk_buff));
4132
4133                page = virt_to_head_page(from->head);
4134                offset = from->data - (unsigned char *)page_address(page);
4135
4136                skb_fill_page_desc(to, skb_shinfo(to)->nr_frags,
4137                                   page, offset, skb_headlen(from));
4138                *fragstolen = true;
4139        } else {
4140                if (skb_shinfo(to)->nr_frags +
4141                    skb_shinfo(from)->nr_frags > MAX_SKB_FRAGS)
4142                        return false;
4143
4144                delta = from->truesize - SKB_TRUESIZE(skb_end_offset(from));
4145        }
4146
4147        WARN_ON_ONCE(delta < len);
4148
4149        memcpy(skb_shinfo(to)->frags + skb_shinfo(to)->nr_frags,
4150               skb_shinfo(from)->frags,
4151               skb_shinfo(from)->nr_frags * sizeof(skb_frag_t));
4152        skb_shinfo(to)->nr_frags += skb_shinfo(from)->nr_frags;
4153
4154        if (!skb_cloned(from))
4155                skb_shinfo(from)->nr_frags = 0;
4156
4157        /* if the skb is not cloned this does nothing
4158         * since we set nr_frags to 0.
4159         */
4160        for (i = 0; i < skb_shinfo(from)->nr_frags; i++)
4161                skb_frag_ref(from, i);
4162
4163        to->truesize += delta;
4164        to->len += len;
4165        to->data_len += len;
4166
4167        *delta_truesize = delta;
4168        return true;
4169}
4170EXPORT_SYMBOL(skb_try_coalesce);
4171
4172/**
4173 * skb_scrub_packet - scrub an skb
4174 *
4175 * @skb: buffer to clean
4176 * @xnet: packet is crossing netns
4177 *
4178 * skb_scrub_packet can be used after encapsulating or decapsulting a packet
4179 * into/from a tunnel. Some information have to be cleared during these
4180 * operations.
4181 * skb_scrub_packet can also be used to clean a skb before injecting it in
4182 * another namespace (@xnet == true). We have to clear all information in the
4183 * skb that could impact namespace isolation.
4184 */
4185void skb_scrub_packet(struct sk_buff *skb, bool xnet)
4186{
4187        skb->tstamp.tv64 = 0;
4188        skb->pkt_type = PACKET_HOST;
4189        skb->skb_iif = 0;
4190        skb->ignore_df = 0;
4191        skb_dst_drop(skb);
4192        secpath_reset(skb);
4193        nf_reset(skb);
4194        nf_reset_trace(skb);
4195
4196        if (!xnet)
4197                return;
4198
4199        skb_orphan(skb);
4200        skb->mark = 0;
4201}
4202EXPORT_SYMBOL_GPL(skb_scrub_packet);
4203
4204/**
4205 * skb_gso_transport_seglen - Return length of individual segments of a gso packet
4206 *
4207 * @skb: GSO skb
4208 *
4209 * skb_gso_transport_seglen is used to determine the real size of the
4210 * individual segments, including Layer4 headers (TCP/UDP).
4211 *
4212 * The MAC/L2 or network (IP, IPv6) headers are not accounted for.
4213 */
4214unsigned int skb_gso_transport_seglen(const struct sk_buff *skb)
4215{
4216        const struct skb_shared_info *shinfo = skb_shinfo(skb);
4217        unsigned int thlen = 0;
4218
4219        if (skb->encapsulation) {
4220                thlen = skb_inner_transport_header(skb) -
4221                        skb_transport_header(skb);
4222
4223                if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)))
4224                        thlen += inner_tcp_hdrlen(skb);
4225        } else if (likely(shinfo->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6))) {
4226                thlen = tcp_hdrlen(skb);
4227        }
4228        /* UFO sets gso_size to the size of the fragmentation
4229         * payload, i.e. the size of the L4 (UDP) header is already
4230         * accounted for.
4231         */
4232        return thlen + shinfo->gso_size;
4233}
4234EXPORT_SYMBOL_GPL(skb_gso_transport_seglen);
4235
4236static struct sk_buff *skb_reorder_vlan_header(struct sk_buff *skb)
4237{
4238        if (skb_cow(skb, skb_headroom(skb)) < 0) {
4239                kfree_skb(skb);
4240                return NULL;
4241        }
4242
4243        memmove(skb->data - ETH_HLEN, skb->data - skb->mac_len - VLAN_HLEN,
4244                2 * ETH_ALEN);
4245        skb->mac_header += VLAN_HLEN;
4246        return skb;
4247}
4248
4249struct sk_buff *skb_vlan_untag(struct sk_buff *skb)
4250{
4251        struct vlan_hdr *vhdr;
4252        u16 vlan_tci;
4253
4254        if (unlikely(vlan_tx_tag_present(skb))) {
4255                /* vlan_tci is already set-up so leave this for another time */
4256                return skb;
4257        }
4258
4259        skb = skb_share_check(skb, GFP_ATOMIC);
4260        if (unlikely(!skb))
4261                goto err_free;
4262
4263        if (unlikely(!pskb_may_pull(skb, VLAN_HLEN)))
4264                goto err_free;
4265
4266        vhdr = (struct vlan_hdr *)skb->data;
4267        vlan_tci = ntohs(vhdr->h_vlan_TCI);
4268        __vlan_hwaccel_put_tag(skb, skb->protocol, vlan_tci);
4269
4270        skb_pull_rcsum(skb, VLAN_HLEN);
4271        vlan_set_encap_proto(skb, vhdr);
4272
4273        skb = skb_reorder_vlan_header(skb);
4274        if (unlikely(!skb))
4275                goto err_free;
4276
4277        skb_reset_network_header(skb);
4278        skb_reset_transport_header(skb);
4279        skb_reset_mac_len(skb);
4280
4281        return skb;
4282
4283err_free:
4284        kfree_skb(skb);
4285        return NULL;
4286}
4287EXPORT_SYMBOL(skb_vlan_untag);
4288
4289/**
4290 * alloc_skb_with_frags - allocate skb with page frags
4291 *
4292 * @header_len: size of linear part
4293 * @data_len: needed length in frags
4294 * @max_page_order: max page order desired.
4295 * @errcode: pointer to error code if any
4296 * @gfp_mask: allocation mask
4297 *
4298 * This can be used to allocate a paged skb, given a maximal order for frags.
4299 */
4300struct sk_buff *alloc_skb_with_frags(unsigned long header_len,
4301                                     unsigned long data_len,
4302                                     int max_page_order,
4303                                     int *errcode,
4304                                     gfp_t gfp_mask)
4305{
4306        int npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
4307        unsigned long chunk;
4308        struct sk_buff *skb;
4309        struct page *page;
4310        gfp_t gfp_head;
4311        int i;
4312
4313        *errcode = -EMSGSIZE;
4314        /* Note this test could be relaxed, if we succeed to allocate
4315         * high order pages...
4316         */
4317        if (npages > MAX_SKB_FRAGS)
4318                return NULL;
4319
4320        gfp_head = gfp_mask;
4321        if (gfp_head & __GFP_WAIT)
4322                gfp_head |= __GFP_REPEAT;
4323
4324        *errcode = -ENOBUFS;
4325        skb = alloc_skb(header_len, gfp_head);
4326        if (!skb)
4327                return NULL;
4328
4329        skb->truesize += npages << PAGE_SHIFT;
4330
4331        for (i = 0; npages > 0; i++) {
4332                int order = max_page_order;
4333
4334                while (order) {
4335                        if (npages >= 1 << order) {
4336                                page = alloc_pages((gfp_mask & ~__GFP_WAIT) |
4337                                                   __GFP_COMP |
4338                                                   __GFP_NOWARN |
4339                                                   __GFP_NORETRY,
4340                                                   order);
4341                                if (page)
4342                                        goto fill_page;
4343                                /* Do not retry other high order allocations */
4344                                order = 1;
4345                                max_page_order = 0;
4346                        }
4347                        order--;
4348                }
4349                page = alloc_page(gfp_mask);
4350                if (!page)
4351                        goto failure;
4352fill_page:
4353                chunk = min_t(unsigned long, data_len,
4354                              PAGE_SIZE << order);
4355                skb_fill_page_desc(skb, i, page, 0, chunk);
4356                data_len -= chunk;
4357                npages -= 1 << order;
4358        }
4359        return skb;
4360
4361failure:
4362        kfree_skb(skb);
4363        return NULL;
4364}
4365EXPORT_SYMBOL(alloc_skb_with_frags);
Note: See TracBrowser for help on using the repository browser.