]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - net/core/skbuff.c
33245ef54c3bd6982abed459cc6c0ef7935cb21f
[~shefty/rdma-dev.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/kmemcheck.h>
45 #include <linux/mm.h>
46 #include <linux/interrupt.h>
47 #include <linux/in.h>
48 #include <linux/inet.h>
49 #include <linux/slab.h>
50 #include <linux/netdevice.h>
51 #ifdef CONFIG_NET_CLS_ACT
52 #include <net/pkt_sched.h>
53 #endif
54 #include <linux/string.h>
55 #include <linux/skbuff.h>
56 #include <linux/splice.h>
57 #include <linux/cache.h>
58 #include <linux/rtnetlink.h>
59 #include <linux/init.h>
60 #include <linux/scatterlist.h>
61 #include <linux/errqueue.h>
62 #include <linux/prefetch.h>
63
64 #include <net/protocol.h>
65 #include <net/dst.h>
66 #include <net/sock.h>
67 #include <net/checksum.h>
68 #include <net/xfrm.h>
69
70 #include <asm/uaccess.h>
71 #include <trace/events/skb.h>
72 #include <linux/highmem.h>
73
74 struct kmem_cache *skbuff_head_cache __read_mostly;
75 static struct kmem_cache *skbuff_fclone_cache __read_mostly;
76
77 static void sock_pipe_buf_release(struct pipe_inode_info *pipe,
78                                   struct pipe_buffer *buf)
79 {
80         put_page(buf->page);
81 }
82
83 static void sock_pipe_buf_get(struct pipe_inode_info *pipe,
84                                 struct pipe_buffer *buf)
85 {
86         get_page(buf->page);
87 }
88
89 static int sock_pipe_buf_steal(struct pipe_inode_info *pipe,
90                                struct pipe_buffer *buf)
91 {
92         return 1;
93 }
94
95
96 /* Pipe buffer operations for a socket. */
97 static const struct pipe_buf_operations sock_pipe_buf_ops = {
98         .can_merge = 0,
99         .map = generic_pipe_buf_map,
100         .unmap = generic_pipe_buf_unmap,
101         .confirm = generic_pipe_buf_confirm,
102         .release = sock_pipe_buf_release,
103         .steal = sock_pipe_buf_steal,
104         .get = sock_pipe_buf_get,
105 };
106
107 /**
108  *      skb_panic - private function for out-of-line support
109  *      @skb:   buffer
110  *      @sz:    size
111  *      @addr:  address
112  *      @msg:   skb_over_panic or skb_under_panic
113  *
114  *      Out-of-line support for skb_put() and skb_push().
115  *      Called via the wrapper skb_over_panic() or skb_under_panic().
116  *      Keep out of line to prevent kernel bloat.
117  *      __builtin_return_address is not used because it is not always reliable.
118  */
119 static void skb_panic(struct sk_buff *skb, unsigned int sz, void *addr,
120                       const char msg[])
121 {
122         pr_emerg("%s: text:%p len:%d put:%d head:%p data:%p tail:%#lx end:%#lx dev:%s\n",
123                  msg, addr, skb->len, sz, skb->head, skb->data,
124                  (unsigned long)skb->tail, (unsigned long)skb->end,
125                  skb->dev ? skb->dev->name : "<NULL>");
126         BUG();
127 }
128
129 static void skb_over_panic(struct sk_buff *skb, unsigned int sz, void *addr)
130 {
131         skb_panic(skb, sz, addr, __func__);
132 }
133
134 static void skb_under_panic(struct sk_buff *skb, unsigned int sz, void *addr)
135 {
136         skb_panic(skb, sz, addr, __func__);
137 }
138
139 /*
140  * kmalloc_reserve is a wrapper around kmalloc_node_track_caller that tells
141  * the caller if emergency pfmemalloc reserves are being used. If it is and
142  * the socket is later found to be SOCK_MEMALLOC then PFMEMALLOC reserves
143  * may be used. Otherwise, the packet data may be discarded until enough
144  * memory is free
145  */
146 #define kmalloc_reserve(size, gfp, node, pfmemalloc) \
147          __kmalloc_reserve(size, gfp, node, _RET_IP_, pfmemalloc)
148
149 static void *__kmalloc_reserve(size_t size, gfp_t flags, int node,
150                                unsigned long ip, bool *pfmemalloc)
151 {
152         void *obj;
153         bool ret_pfmemalloc = false;
154
155         /*
156          * Try a regular allocation, when that fails and we're not entitled
157          * to the reserves, fail.
158          */
159         obj = kmalloc_node_track_caller(size,
160                                         flags | __GFP_NOMEMALLOC | __GFP_NOWARN,
161                                         node);
162         if (obj || !(gfp_pfmemalloc_allowed(flags)))
163                 goto out;
164
165         /* Try again but now we are using pfmemalloc reserves */
166         ret_pfmemalloc = true;
167         obj = kmalloc_node_track_caller(size, flags, node);
168
169 out:
170         if (pfmemalloc)
171                 *pfmemalloc = ret_pfmemalloc;
172
173         return obj;
174 }
175
176 /*      Allocate a new skbuff. We do this ourselves so we can fill in a few
177  *      'private' fields and also do memory statistics to find all the
178  *      [BEEP] leaks.
179  *
180  */
181
182 /**
183  *      __alloc_skb     -       allocate a network buffer
184  *      @size: size to allocate
185  *      @gfp_mask: allocation mask
186  *      @flags: If SKB_ALLOC_FCLONE is set, allocate from fclone cache
187  *              instead of head cache and allocate a cloned (child) skb.
188  *              If SKB_ALLOC_RX is set, __GFP_MEMALLOC will be used for
189  *              allocations in case the data is required for writeback
190  *      @node: numa node to allocate memory on
191  *
192  *      Allocate a new &sk_buff. The returned buffer has no headroom and a
193  *      tail room of at least size bytes. The object has a reference count
194  *      of one. The return is the buffer. On a failure the return is %NULL.
195  *
196  *      Buffers may only be allocated from interrupts using a @gfp_mask of
197  *      %GFP_ATOMIC.
198  */
199 struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
200                             int flags, int node)
201 {
202         struct kmem_cache *cache;
203         struct skb_shared_info *shinfo;
204         struct sk_buff *skb;
205         u8 *data;
206         bool pfmemalloc;
207
208         cache = (flags & SKB_ALLOC_FCLONE)
209                 ? skbuff_fclone_cache : skbuff_head_cache;
210
211         if (sk_memalloc_socks() && (flags & SKB_ALLOC_RX))
212                 gfp_mask |= __GFP_MEMALLOC;
213
214         /* Get the HEAD */
215         skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node);
216         if (!skb)
217                 goto out;
218         prefetchw(skb);
219
220         /* We do our best to align skb_shared_info on a separate cache
221          * line. It usually works because kmalloc(X > SMP_CACHE_BYTES) gives
222          * aligned memory blocks, unless SLUB/SLAB debug is enabled.
223          * Both skb->head and skb_shared_info are cache line aligned.
224          */
225         size = SKB_DATA_ALIGN(size);
226         size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
227         data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc);
228         if (!data)
229                 goto nodata;
230         /* kmalloc(size) might give us more room than requested.
231          * Put skb_shared_info exactly at the end of allocated zone,
232          * to allow max possible filling before reallocation.
233          */
234         size = SKB_WITH_OVERHEAD(ksize(data));
235         prefetchw(data + size);
236
237         /*
238          * Only clear those fields we need to clear, not those that we will
239          * actually initialise below. Hence, don't put any more fields after
240          * the tail pointer in struct sk_buff!
241          */
242         memset(skb, 0, offsetof(struct sk_buff, tail));
243         /* Account for allocated memory : skb + skb->head */
244         skb->truesize = SKB_TRUESIZE(size);
245         skb->pfmemalloc = pfmemalloc;
246         atomic_set(&skb->users, 1);
247         skb->head = data;
248         skb->data = data;
249         skb_reset_tail_pointer(skb);
250         skb->end = skb->tail + size;
251 #ifdef NET_SKBUFF_DATA_USES_OFFSET
252         skb->mac_header = ~0U;
253         skb->transport_header = ~0U;
254 #endif
255
256         /* make sure we initialize shinfo sequentially */
257         shinfo = skb_shinfo(skb);
258         memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
259         atomic_set(&shinfo->dataref, 1);
260         kmemcheck_annotate_variable(shinfo->destructor_arg);
261
262         if (flags & SKB_ALLOC_FCLONE) {
263                 struct sk_buff *child = skb + 1;
264                 atomic_t *fclone_ref = (atomic_t *) (child + 1);
265
266                 kmemcheck_annotate_bitfield(child, flags1);
267                 kmemcheck_annotate_bitfield(child, flags2);
268                 skb->fclone = SKB_FCLONE_ORIG;
269                 atomic_set(fclone_ref, 1);
270
271                 child->fclone = SKB_FCLONE_UNAVAILABLE;
272                 child->pfmemalloc = pfmemalloc;
273         }
274 out:
275         return skb;
276 nodata:
277         kmem_cache_free(cache, skb);
278         skb = NULL;
279         goto out;
280 }
281 EXPORT_SYMBOL(__alloc_skb);
282
283 /**
284  * build_skb - build a network buffer
285  * @data: data buffer provided by caller
286  * @frag_size: size of fragment, or 0 if head was kmalloced
287  *
288  * Allocate a new &sk_buff. Caller provides space holding head and
289  * skb_shared_info. @data must have been allocated by kmalloc()
290  * The return is the new skb buffer.
291  * On a failure the return is %NULL, and @data is not freed.
292  * Notes :
293  *  Before IO, driver allocates only data buffer where NIC put incoming frame
294  *  Driver should add room at head (NET_SKB_PAD) and
295  *  MUST add room at tail (SKB_DATA_ALIGN(skb_shared_info))
296  *  After IO, driver calls build_skb(), to allocate sk_buff and populate it
297  *  before giving packet to stack.
298  *  RX rings only contains data buffers, not full skbs.
299  */
300 struct sk_buff *build_skb(void *data, unsigned int frag_size)
301 {
302         struct skb_shared_info *shinfo;
303         struct sk_buff *skb;
304         unsigned int size = frag_size ? : ksize(data);
305
306         skb = kmem_cache_alloc(skbuff_head_cache, GFP_ATOMIC);
307         if (!skb)
308                 return NULL;
309
310         size -= SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
311
312         memset(skb, 0, offsetof(struct sk_buff, tail));
313         skb->truesize = SKB_TRUESIZE(size);
314         skb->head_frag = frag_size != 0;
315         atomic_set(&skb->users, 1);
316         skb->head = data;
317         skb->data = data;
318         skb_reset_tail_pointer(skb);
319         skb->end = skb->tail + size;
320 #ifdef NET_SKBUFF_DATA_USES_OFFSET
321         skb->mac_header = ~0U;
322         skb->transport_header = ~0U;
323 #endif
324
325         /* make sure we initialize shinfo sequentially */
326         shinfo = skb_shinfo(skb);
327         memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
328         atomic_set(&shinfo->dataref, 1);
329         kmemcheck_annotate_variable(shinfo->destructor_arg);
330
331         return skb;
332 }
333 EXPORT_SYMBOL(build_skb);
334
335 struct netdev_alloc_cache {
336         struct page_frag        frag;
337         /* we maintain a pagecount bias, so that we dont dirty cache line
338          * containing page->_count every time we allocate a fragment.
339          */
340         unsigned int            pagecnt_bias;
341 };
342 static DEFINE_PER_CPU(struct netdev_alloc_cache, netdev_alloc_cache);
343
344 static void *__netdev_alloc_frag(unsigned int fragsz, gfp_t gfp_mask)
345 {
346         struct netdev_alloc_cache *nc;
347         void *data = NULL;
348         int order;
349         unsigned long flags;
350
351         local_irq_save(flags);
352         nc = &__get_cpu_var(netdev_alloc_cache);
353         if (unlikely(!nc->frag.page)) {
354 refill:
355                 for (order = NETDEV_FRAG_PAGE_MAX_ORDER; ;) {
356                         gfp_t gfp = gfp_mask;
357
358                         if (order)
359                                 gfp |= __GFP_COMP | __GFP_NOWARN;
360                         nc->frag.page = alloc_pages(gfp, order);
361                         if (likely(nc->frag.page))
362                                 break;
363                         if (--order < 0)
364                                 goto end;
365                 }
366                 nc->frag.size = PAGE_SIZE << order;
367 recycle:
368                 atomic_set(&nc->frag.page->_count, NETDEV_PAGECNT_MAX_BIAS);
369                 nc->pagecnt_bias = NETDEV_PAGECNT_MAX_BIAS;
370                 nc->frag.offset = 0;
371         }
372
373         if (nc->frag.offset + fragsz > nc->frag.size) {
374                 /* avoid unnecessary locked operations if possible */
375                 if ((atomic_read(&nc->frag.page->_count) == nc->pagecnt_bias) ||
376                     atomic_sub_and_test(nc->pagecnt_bias, &nc->frag.page->_count))
377                         goto recycle;
378                 goto refill;
379         }
380
381         data = page_address(nc->frag.page) + nc->frag.offset;
382         nc->frag.offset += fragsz;
383         nc->pagecnt_bias--;
384 end:
385         local_irq_restore(flags);
386         return data;
387 }
388
389 /**
390  * netdev_alloc_frag - allocate a page fragment
391  * @fragsz: fragment size
392  *
393  * Allocates a frag from a page for receive buffer.
394  * Uses GFP_ATOMIC allocations.
395  */
396 void *netdev_alloc_frag(unsigned int fragsz)
397 {
398         return __netdev_alloc_frag(fragsz, GFP_ATOMIC | __GFP_COLD);
399 }
400 EXPORT_SYMBOL(netdev_alloc_frag);
401
402 /**
403  *      __netdev_alloc_skb - allocate an skbuff for rx on a specific device
404  *      @dev: network device to receive on
405  *      @length: length to allocate
406  *      @gfp_mask: get_free_pages mask, passed to alloc_skb
407  *
408  *      Allocate a new &sk_buff and assign it a usage count of one. The
409  *      buffer has unspecified headroom built in. Users should allocate
410  *      the headroom they think they need without accounting for the
411  *      built in space. The built in space is used for optimisations.
412  *
413  *      %NULL is returned if there is no free memory.
414  */
415 struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
416                                    unsigned int length, gfp_t gfp_mask)
417 {
418         struct sk_buff *skb = NULL;
419         unsigned int fragsz = SKB_DATA_ALIGN(length + NET_SKB_PAD) +
420                               SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
421
422         if (fragsz <= PAGE_SIZE && !(gfp_mask & (__GFP_WAIT | GFP_DMA))) {
423                 void *data;
424
425                 if (sk_memalloc_socks())
426                         gfp_mask |= __GFP_MEMALLOC;
427
428                 data = __netdev_alloc_frag(fragsz, gfp_mask);
429
430                 if (likely(data)) {
431                         skb = build_skb(data, fragsz);
432                         if (unlikely(!skb))
433                                 put_page(virt_to_head_page(data));
434                 }
435         } else {
436                 skb = __alloc_skb(length + NET_SKB_PAD, gfp_mask,
437                                   SKB_ALLOC_RX, NUMA_NO_NODE);
438         }
439         if (likely(skb)) {
440                 skb_reserve(skb, NET_SKB_PAD);
441                 skb->dev = dev;
442         }
443         return skb;
444 }
445 EXPORT_SYMBOL(__netdev_alloc_skb);
446
447 void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
448                      int size, unsigned int truesize)
449 {
450         skb_fill_page_desc(skb, i, page, off, size);
451         skb->len += size;
452         skb->data_len += size;
453         skb->truesize += truesize;
454 }
455 EXPORT_SYMBOL(skb_add_rx_frag);
456
457 static void skb_drop_list(struct sk_buff **listp)
458 {
459         struct sk_buff *list = *listp;
460
461         *listp = NULL;
462
463         do {
464                 struct sk_buff *this = list;
465                 list = list->next;
466                 kfree_skb(this);
467         } while (list);
468 }
469
470 static inline void skb_drop_fraglist(struct sk_buff *skb)
471 {
472         skb_drop_list(&skb_shinfo(skb)->frag_list);
473 }
474
475 static void skb_clone_fraglist(struct sk_buff *skb)
476 {
477         struct sk_buff *list;
478
479         skb_walk_frags(skb, list)
480                 skb_get(list);
481 }
482
483 static void skb_free_head(struct sk_buff *skb)
484 {
485         if (skb->head_frag)
486                 put_page(virt_to_head_page(skb->head));
487         else
488                 kfree(skb->head);
489 }
490
491 static void skb_release_data(struct sk_buff *skb)
492 {
493         if (!skb->cloned ||
494             !atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
495                                &skb_shinfo(skb)->dataref)) {
496                 if (skb_shinfo(skb)->nr_frags) {
497                         int i;
498                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
499                                 skb_frag_unref(skb, i);
500                 }
501
502                 /*
503                  * If skb buf is from userspace, we need to notify the caller
504                  * the lower device DMA has done;
505                  */
506                 if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
507                         struct ubuf_info *uarg;
508
509                         uarg = skb_shinfo(skb)->destructor_arg;
510                         if (uarg->callback)
511                                 uarg->callback(uarg, true);
512                 }
513
514                 if (skb_has_frag_list(skb))
515                         skb_drop_fraglist(skb);
516
517                 skb_free_head(skb);
518         }
519 }
520
521 /*
522  *      Free an skbuff by memory without cleaning the state.
523  */
524 static void kfree_skbmem(struct sk_buff *skb)
525 {
526         struct sk_buff *other;
527         atomic_t *fclone_ref;
528
529         switch (skb->fclone) {
530         case SKB_FCLONE_UNAVAILABLE:
531                 kmem_cache_free(skbuff_head_cache, skb);
532                 break;
533
534         case SKB_FCLONE_ORIG:
535                 fclone_ref = (atomic_t *) (skb + 2);
536                 if (atomic_dec_and_test(fclone_ref))
537                         kmem_cache_free(skbuff_fclone_cache, skb);
538                 break;
539
540         case SKB_FCLONE_CLONE:
541                 fclone_ref = (atomic_t *) (skb + 1);
542                 other = skb - 1;
543
544                 /* The clone portion is available for
545                  * fast-cloning again.
546                  */
547                 skb->fclone = SKB_FCLONE_UNAVAILABLE;
548
549                 if (atomic_dec_and_test(fclone_ref))
550                         kmem_cache_free(skbuff_fclone_cache, other);
551                 break;
552         }
553 }
554
555 static void skb_release_head_state(struct sk_buff *skb)
556 {
557         skb_dst_drop(skb);
558 #ifdef CONFIG_XFRM
559         secpath_put(skb->sp);
560 #endif
561         if (skb->destructor) {
562                 WARN_ON(in_irq());
563                 skb->destructor(skb);
564         }
565 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
566         nf_conntrack_put(skb->nfct);
567 #endif
568 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
569         nf_conntrack_put_reasm(skb->nfct_reasm);
570 #endif
571 #ifdef CONFIG_BRIDGE_NETFILTER
572         nf_bridge_put(skb->nf_bridge);
573 #endif
574 /* XXX: IS this still necessary? - JHS */
575 #ifdef CONFIG_NET_SCHED
576         skb->tc_index = 0;
577 #ifdef CONFIG_NET_CLS_ACT
578         skb->tc_verd = 0;
579 #endif
580 #endif
581 }
582
583 /* Free everything but the sk_buff shell. */
584 static void skb_release_all(struct sk_buff *skb)
585 {
586         skb_release_head_state(skb);
587         skb_release_data(skb);
588 }
589
590 /**
591  *      __kfree_skb - private function
592  *      @skb: buffer
593  *
594  *      Free an sk_buff. Release anything attached to the buffer.
595  *      Clean the state. This is an internal helper function. Users should
596  *      always call kfree_skb
597  */
598
599 void __kfree_skb(struct sk_buff *skb)
600 {
601         skb_release_all(skb);
602         kfree_skbmem(skb);
603 }
604 EXPORT_SYMBOL(__kfree_skb);
605
606 /**
607  *      kfree_skb - free an sk_buff
608  *      @skb: buffer to free
609  *
610  *      Drop a reference to the buffer and free it if the usage count has
611  *      hit zero.
612  */
613 void kfree_skb(struct sk_buff *skb)
614 {
615         if (unlikely(!skb))
616                 return;
617         if (likely(atomic_read(&skb->users) == 1))
618                 smp_rmb();
619         else if (likely(!atomic_dec_and_test(&skb->users)))
620                 return;
621         trace_kfree_skb(skb, __builtin_return_address(0));
622         __kfree_skb(skb);
623 }
624 EXPORT_SYMBOL(kfree_skb);
625
626 /**
627  *      skb_tx_error - report an sk_buff xmit error
628  *      @skb: buffer that triggered an error
629  *
630  *      Report xmit error if a device callback is tracking this skb.
631  *      skb must be freed afterwards.
632  */
633 void skb_tx_error(struct sk_buff *skb)
634 {
635         if (skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY) {
636                 struct ubuf_info *uarg;
637
638                 uarg = skb_shinfo(skb)->destructor_arg;
639                 if (uarg->callback)
640                         uarg->callback(uarg, false);
641                 skb_shinfo(skb)->tx_flags &= ~SKBTX_DEV_ZEROCOPY;
642         }
643 }
644 EXPORT_SYMBOL(skb_tx_error);
645
646 /**
647  *      consume_skb - free an skbuff
648  *      @skb: buffer to free
649  *
650  *      Drop a ref to the buffer and free it if the usage count has hit zero
651  *      Functions identically to kfree_skb, but kfree_skb assumes that the frame
652  *      is being dropped after a failure and notes that
653  */
654 void consume_skb(struct sk_buff *skb)
655 {
656         if (unlikely(!skb))
657                 return;
658         if (likely(atomic_read(&skb->users) == 1))
659                 smp_rmb();
660         else if (likely(!atomic_dec_and_test(&skb->users)))
661                 return;
662         trace_consume_skb(skb);
663         __kfree_skb(skb);
664 }
665 EXPORT_SYMBOL(consume_skb);
666
667 static void __copy_skb_header(struct sk_buff *new, const struct sk_buff *old)
668 {
669         new->tstamp             = old->tstamp;
670         new->dev                = old->dev;
671         new->transport_header   = old->transport_header;
672         new->network_header     = old->network_header;
673         new->mac_header         = old->mac_header;
674         new->inner_transport_header = old->inner_transport_header;
675         new->inner_network_header = old->inner_network_header;
676         skb_dst_copy(new, old);
677         new->rxhash             = old->rxhash;
678         new->ooo_okay           = old->ooo_okay;
679         new->l4_rxhash          = old->l4_rxhash;
680         new->no_fcs             = old->no_fcs;
681         new->encapsulation      = old->encapsulation;
682 #ifdef CONFIG_XFRM
683         new->sp                 = secpath_get(old->sp);
684 #endif
685         memcpy(new->cb, old->cb, sizeof(old->cb));
686         new->csum               = old->csum;
687         new->local_df           = old->local_df;
688         new->pkt_type           = old->pkt_type;
689         new->ip_summed          = old->ip_summed;
690         skb_copy_queue_mapping(new, old);
691         new->priority           = old->priority;
692 #if IS_ENABLED(CONFIG_IP_VS)
693         new->ipvs_property      = old->ipvs_property;
694 #endif
695         new->pfmemalloc         = old->pfmemalloc;
696         new->protocol           = old->protocol;
697         new->mark               = old->mark;
698         new->skb_iif            = old->skb_iif;
699         __nf_copy(new, old);
700 #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE)
701         new->nf_trace           = old->nf_trace;
702 #endif
703 #ifdef CONFIG_NET_SCHED
704         new->tc_index           = old->tc_index;
705 #ifdef CONFIG_NET_CLS_ACT
706         new->tc_verd            = old->tc_verd;
707 #endif
708 #endif
709         new->vlan_tci           = old->vlan_tci;
710
711         skb_copy_secmark(new, old);
712 }
713
714 /*
715  * You should not add any new code to this function.  Add it to
716  * __copy_skb_header above instead.
717  */
718 static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
719 {
720 #define C(x) n->x = skb->x