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