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