include/linux/skbuff.h

   1 /*
   2  *      Definitions for the 'struct sk_buff' memory handlers.
   3  *
   4  *      Authors:
   5  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
   6  *              Florian La Roche, <rzsfl@rz.uni-sb.de>
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License
  10  *      as published by the Free Software Foundation; either version
  11  *      2 of the License, or (at your option) any later version.
  12  */
  13
  14 #ifndef _LINUX_SKBUFF_H
  15 #define _LINUX_SKBUFF_H
  16
  17 #include <linux/kernel.h>
  18 #include <linux/kmemcheck.h>
  19 #include <linux/compiler.h>
  20 #include <linux/time.h>
  21 #include <linux/cache.h>
  22
  23 #include <linux/atomic.h>
  24 #include <asm/types.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/net.h>
  27 #include <linux/textsearch.h>
  28 #include <net/checksum.h>
  29 #include <linux/rcupdate.h>
  30 #include <linux/dmaengine.h>
  31 #include <linux/hrtimer.h>
  32
  33 /* Don't change this without changing skb_csum_unnecessary! */
  34 #define CHECKSUM_NONE 0
  35 #define CHECKSUM_UNNECESSARY 1
  36 #define CHECKSUM_COMPLETE 2
  37 #define CHECKSUM_PARTIAL 3
  38
  39 #define SKB_DATA_ALIGN(X)       (((X) + (SMP_CACHE_BYTES - 1)) & \
  40                                  ~(SMP_CACHE_BYTES - 1))
  41 #define SKB_WITH_OVERHEAD(X)    \
  42         ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
  43 #define SKB_MAX_ORDER(X, ORDER) \
  44         SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
  45 #define SKB_MAX_HEAD(X)         (SKB_MAX_ORDER((X), 0))
  46 #define SKB_MAX_ALLOC           (SKB_MAX_ORDER(0, 2))
  47
  48 /* A. Checksumming of received packets by device.
  49  *
  50  *      NONE: device failed to checksum this packet.
  51  *              skb->csum is undefined.
  52  *
  53  *      UNNECESSARY: device parsed packet and wouldbe verified checksum.
  54  *              skb->csum is undefined.
  55  *            It is bad option, but, unfortunately, many of vendors do this.
  56  *            Apparently with secret goal to sell you new device, when you
  57  *            will add new protocol to your host. F.e. IPv6. 8)
  58  *
  59  *      COMPLETE: the most generic way. Device supplied checksum of _all_
  60  *          the packet as seen by netif_rx in skb->csum.
  61  *          NOTE: Even if device supports only some protocols, but
  62  *          is able to produce some skb->csum, it MUST use COMPLETE,
  63  *          not UNNECESSARY.
  64  *
  65  *      PARTIAL: identical to the case for output below.  This may occur
  66  *          on a packet received directly from another Linux OS, e.g.,
  67  *          a virtualised Linux kernel on the same host.  The packet can
  68  *          be treated in the same way as UNNECESSARY except that on
  69  *          output (i.e., forwarding) the checksum must be filled in
  70  *          by the OS or the hardware.
  71  *
  72  * B. Checksumming on output.
  73  *
  74  *      NONE: skb is checksummed by protocol or csum is not required.
  75  *
  76  *      PARTIAL: device is required to csum packet as seen by hard_start_xmit
  77  *      from skb->csum_start to the end and to record the checksum
  78  *      at skb->csum_start + skb->csum_offset.
  79  *
  80  *      Device must show its capabilities in dev->features, set
  81  *      at device setup time.
  82  *      NETIF_F_HW_CSUM - it is clever device, it is able to checksum
  83  *                        everything.
  84  *      NETIF_F_NO_CSUM - loopback or reliable single hop media.
  85  *      NETIF_F_IP_CSUM - device is dumb. It is able to csum only
  86  *                        TCP/UDP over IPv4. Sigh. Vendors like this
  87  *                        way by an unknown reason. Though, see comment above
  88  *                        about CHECKSUM_UNNECESSARY. 8)
  89  *      NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
  90  *
  91  *      Any questions? No questions, good.              --ANK
  92  */
  93
  94 struct net_device;
  95 struct scatterlist;
  96 struct pipe_inode_info;
  97
  98 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  99 struct nf_conntrack {
 100         atomic_t use;
 101 };
 102 #endif
 103
 104 #ifdef CONFIG_BRIDGE_NETFILTER
 105 struct nf_bridge_info {
 106         atomic_t use;
 107         struct net_device *physindev;
 108         struct net_device *physoutdev;
 109         unsigned int mask;
 110         unsigned long data[32 / sizeof(unsigned long)];
 111 };
 112 #endif
 113
 114 struct sk_buff_head {
 115         /* These two members must be first. */
 116         struct sk_buff  *next;
 117         struct sk_buff  *prev;
 118
 119         __u32           qlen;
 120         spinlock_t      lock;
 121 };
 122
 123 struct sk_buff;
 124
 125 /* To allow 64K frame to be packed as single skb without frag_list. Since
 126  * GRO uses frags we allocate at least 16 regardless of page size.
 127  */
 128 #if (65536/PAGE_SIZE + 2) < 16
 129 #define MAX_SKB_FRAGS 16UL
 130 #else
 131 #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
 132 #endif
 133
 134 typedef struct skb_frag_struct skb_frag_t;
 135
 136 struct skb_frag_struct {
 137         struct page *page;
 138 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
 139         __u32 page_offset;
 140         __u32 size;
 141 #else
 142         __u16 page_offset;
 143         __u16 size;
 144 #endif
 145 };
 146
 147 #define HAVE_HW_TIME_STAMP
 148
 149 /**
 150  * struct skb_shared_hwtstamps - hardware time stamps
 151  * @hwtstamp:   hardware time stamp transformed into duration
 152  *              since arbitrary point in time
 153  * @syststamp:  hwtstamp transformed to system time base
 154  *
 155  * Software time stamps generated by ktime_get_real() are stored in
 156  * skb->tstamp. The relation between the different kinds of time
 157  * stamps is as follows:
 158  *
 159  * syststamp and tstamp can be compared against each other in
 160  * arbitrary combinations.  The accuracy of a
 161  * syststamp/tstamp/"syststamp from other device" comparison is
 162  * limited by the accuracy of the transformation into system time
 163  * base. This depends on the device driver and its underlying
 164  * hardware.
 165  *
 166  * hwtstamps can only be compared against other hwtstamps from
 167  * the same device.
 168  *
 169  * This structure is attached to packets as part of the
 170  * &skb_shared_info. Use skb_hwtstamps() to get a pointer.
 171  */
 172 struct skb_shared_hwtstamps {
 173         ktime_t hwtstamp;
 174         ktime_t syststamp;
 175 };
 176
 177 /* Definitions for tx_flags in struct skb_shared_info */
 178 enum {
 179         /* generate hardware time stamp */
 180         SKBTX_HW_TSTAMP = 1 << 0,
 181
 182         /* generate software time stamp */
 183         SKBTX_SW_TSTAMP = 1 << 1,
 184
 185         /* device driver is going to provide hardware time stamp */
 186         SKBTX_IN_PROGRESS = 1 << 2,
 187
 188         /* ensure the originating sk reference is available on driver level */
 189         SKBTX_DRV_NEEDS_SK_REF = 1 << 3,
 190
 191         /* device driver supports TX zero-copy buffers */
 192         SKBTX_DEV_ZEROCOPY = 1 << 4,
 193 };
 194
 195 /*
 196  * The callback notifies userspace to release buffers when skb DMA is done in
 197  * lower device, the skb last reference should be 0 when calling this.
 198  * The desc is used to track userspace buffer index.
 199  */
 200 struct ubuf_info {
 201         void (*callback)(void *);
 202         void *arg;
 203         unsigned long desc;
 204 };
 205
 206 /* This data is invariant across clones and lives at
 207  * the end of the header data, ie. at skb->end.
 208  */
 209 struct skb_shared_info {
 210         unsigned short  nr_frags;
 211         unsigned short  gso_size;
 212         /* Warning: this field is not always filled in (UFO)! */
 213         unsigned short  gso_segs;
 214         unsigned short  gso_type;
 215         __be32          ip6_frag_id;
 216         __u8            tx_flags;
 217         struct sk_buff  *frag_list;
 218         struct skb_shared_hwtstamps hwtstamps;
 219
 220         /*
 221          * Warning : all fields before dataref are cleared in __alloc_skb()
 222          */
 223         atomic_t        dataref;
 224
 225         /* Intermediate layers must ensure that destructor_arg
 226          * remains valid until skb destructor */
 227         void *          destructor_arg;
 228
 229         /* must be last field, see pskb_expand_head() */
 230         skb_frag_t      frags[MAX_SKB_FRAGS];
 231 };
 232
 233 /* We divide dataref into two halves.  The higher 16 bits hold references
 234  * to the payload part of skb->data.  The lower 16 bits hold references to
 235  * the entire skb->data.  A clone of a headerless skb holds the length of
 236  * the header in skb->hdr_len.
 237  *
 238  * All users must obey the rule that the skb->data reference count must be
 239  * greater than or equal to the payload reference count.
 240  *
 241  * Holding a reference to the payload part means that the user does not
 242  * care about modifications to the header part of skb->data.
 243  */
 244 #define SKB_DATAREF_SHIFT 16
 245 #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
 246
 247
 248 enum {
 249         SKB_FCLONE_UNAVAILABLE,
 250         SKB_FCLONE_ORIG,
 251         SKB_FCLONE_CLONE,
 252 };
 253
 254 enum {
 255         SKB_GSO_TCPV4 = 1 << 0,
 256         SKB_GSO_UDP = 1 << 1,
 257
 258         /* This indicates the skb is from an untrusted source. */
 259         SKB_GSO_DODGY = 1 << 2,
 260
 261         /* This indicates the tcp segment has CWR set. */
 262         SKB_GSO_TCP_ECN = 1 << 3,
 263
 264         SKB_GSO_TCPV6 = 1 << 4,
 265
 266         SKB_GSO_FCOE = 1 << 5,
 267 };
 268
 269 #if BITS_PER_LONG > 32
 270 #define NET_SKBUFF_DATA_USES_OFFSET 1
 271 #endif
 272
 273 #ifdef NET_SKBUFF_DATA_USES_OFFSET
 274 typedef unsigned int sk_buff_data_t;
 275 #else
 276 typedef unsigned char *sk_buff_data_t;
 277 #endif
 278
 279 #if defined(CONFIG_NF_DEFRAG_IPV4) || defined(CONFIG_NF_DEFRAG_IPV4_MODULE) || \
 280     defined(CONFIG_NF_DEFRAG_IPV6) || defined(CONFIG_NF_DEFRAG_IPV6_MODULE)
 281 #define NET_SKBUFF_NF_DEFRAG_NEEDED 1
 282 #endif
 283
 284 /**
 285  *      struct sk_buff - socket buffer
 286  *      @next: Next buffer in list
 287  *      @prev: Previous buffer in list
 288  *      @tstamp: Time we arrived
 289  *      @sk: Socket we are owned by
 290  *      @dev: Device we arrived on/are leaving by
 291  *      @cb: Control buffer. Free for use by every layer. Put private vars here
 292  *      @_skb_refdst: destination entry (with norefcount bit)
 293  *      @sp: the security path, used for xfrm
 294  *      @len: Length of actual data
 295  *      @data_len: Data length
 296  *      @mac_len: Length of link layer header
 297  *      @hdr_len: writable header length of cloned skb
 298  *      @csum: Checksum (must include start/offset pair)
 299  *      @csum_start: Offset from skb->head where checksumming should start
 300  *      @csum_offset: Offset from csum_start where checksum should be stored
 301  *      @priority: Packet queueing priority
 302  *      @local_df: allow local fragmentation
 303  *      @cloned: Head may be cloned (check refcnt to be sure)
 304  *      @ip_summed: Driver fed us an IP checksum
 305  *      @nohdr: Payload reference only, must not modify header
 306  *      @nfctinfo: Relationship of this skb to the connection
 307  *      @pkt_type: Packet class
 308  *      @fclone: skbuff clone status
 309  *      @ipvs_property: skbuff is owned by ipvs
 310  *      @peeked: this packet has been seen already, so stats have been
 311  *              done for it, don't do them again
 312  *      @nf_trace: netfilter packet trace flag
 313  *      @protocol: Packet protocol from driver
 314  *      @destructor: Destruct function
 315  *      @nfct: Associated connection, if any
 316  *      @nfct_reasm: netfilter conntrack re-assembly pointer
 317  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
 318  *      @skb_iif: ifindex of device we arrived on
 319  *      @tc_index: Traffic control index
 320  *      @tc_verd: traffic control verdict
 321  *      @rxhash: the packet hash computed on receive
 322  *      @queue_mapping: Queue mapping for multiqueue devices
 323  *      @ndisc_nodetype: router type (from link layer)
 324  *      @ooo_okay: allow the mapping of a socket to a queue to be changed
 325  *      @dma_cookie: a cookie to one of several possible DMA operations
 326  *              done by skb DMA functions
 327  *      @secmark: security marking
 328  *      @mark: Generic packet mark
 329  *      @dropcount: total number of sk_receive_queue overflows
 330  *      @vlan_tci: vlan tag control information
 331  *      @transport_header: Transport layer header
 332  *      @network_header: Network layer header
 333  *      @mac_header: Link layer header
 334  *      @tail: Tail pointer
 335  *      @end: End pointer
 336  *      @head: Head of buffer
 337  *      @data: Data head pointer
 338  *      @truesize: Buffer size
 339  *      @users: User count - see {datagram,tcp}.c
 340  */
 341
 342 struct sk_buff {
 343         /* These two members must be first. */
 344         struct sk_buff          *next;
 345         struct sk_buff          *prev;
 346
 347         ktime_t                 tstamp;
 348
 349         struct sock             *sk;
 350         struct net_device       *dev;
 351
 352         /*
 353          * This is the control buffer. It is free to use for every
 354          * layer. Please put your private variables there. If you
 355          * want to keep them across layers you have to do a skb_clone()
 356          * first. This is owned by whoever has the skb queued ATM.
 357          */
 358         char                    cb[48] __aligned(8);
 359
 360         unsigned long           _skb_refdst;
 361 #ifdef CONFIG_XFRM
 362         struct  sec_path        *sp;
 363 #endif
 364         unsigned int            len,
 365                                 data_len;
 366         __u16                   mac_len,
 367                                 hdr_len;
 368         union {
 369                 __wsum          csum;
 370                 struct {
 371                         __u16   csum_start;
 372                         __u16   csum_offset;
 373                 };
 374         };
 375         __u32                   priority;
 376         kmemcheck_bitfield_begin(flags1);
 377         __u8                    local_df:1,
 378                                 cloned:1,
 379                                 ip_summed:2,
 380                                 nohdr:1,
 381                                 nfctinfo:3;
 382         __u8                    pkt_type:3,
 383                                 fclone:2,
 384                                 ipvs_property:1,
 385                                 peeked:1,
 386                                 nf_trace:1;
 387         kmemcheck_bitfield_end(flags1);
 388         __be16                  protocol;
 389
 390         void                    (*destructor)(struct sk_buff *skb);
 391 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 392         struct nf_conntrack     *nfct;
 393 #endif
 394 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
 395         struct sk_buff          *nfct_reasm;
 396 #endif
 397 #ifdef CONFIG_BRIDGE_NETFILTER
 398         struct nf_bridge_info   *nf_bridge;
 399 #endif
 400
 401         int                     skb_iif;
 402 #ifdef CONFIG_NET_SCHED
 403         __u16                   tc_index;       /* traffic control index */
 404 #ifdef CONFIG_NET_CLS_ACT
 405         __u16                   tc_verd;        /* traffic control verdict */
 406 #endif
 407 #endif
 408
 409         __u32                   rxhash;
 410
 411         __u16                   queue_mapping;
 412         kmemcheck_bitfield_begin(flags2);
 413 #ifdef CONFIG_IPV6_NDISC_NODETYPE
 414         __u8                    ndisc_nodetype:2;
 415 #endif
 416         __u8                    ooo_okay:1;
 417         kmemcheck_bitfield_end(flags2);
 418
 419         /* 0/13 bit hole */
 420
 421 #ifdef CONFIG_NET_DMA
 422         dma_cookie_t            dma_cookie;
 423 #endif
 424 #ifdef CONFIG_NETWORK_SECMARK
 425         __u32                   secmark;
 426 #endif
 427         union {
 428                 __u32           mark;
 429                 __u32           dropcount;
 430         };
 431
 432         __u16                   vlan_tci;
 433
 434         sk_buff_data_t          transport_header;
 435         sk_buff_data_t          network_header;
 436         sk_buff_data_t          mac_header;
 437         /* These elements must be at the end, see alloc_skb() for details.  */
 438         sk_buff_data_t          tail;
 439         sk_buff_data_t          end;
 440         unsigned char           *head,
 441                                 *data;
 442         unsigned int            truesize;
 443         atomic_t                users;
 444 };
 445
 446 #ifdef __KERNEL__
 447 /*
 448  *      Handling routines are only of interest to the kernel
 449  */
 450 #include <linux/slab.h>
 451
 452 #include <asm/system.h>
 453
 454 /*
 455  * skb might have a dst pointer attached, refcounted or not.
 456  * _skb_refdst low order bit is set if refcount was _not_ taken
 457  */
 458 #define SKB_DST_NOREF   1UL
 459 #define SKB_DST_PTRMASK ~(SKB_DST_NOREF)
 460
 461 /**
 462  * skb_dst - returns skb dst_entry
 463  * @skb: buffer
 464  *
 465  * Returns skb dst_entry, regardless of reference taken or not.
 466  */
 467 static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
 468 {
 469         /* If refdst was not refcounted, check we still are in a
 470          * rcu_read_lock section
 471          */
 472         WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
 473                 !rcu_read_lock_held() &&
 474                 !rcu_read_lock_bh_held());
 475         return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
 476 }
 477
 478 /**
 479  * skb_dst_set - sets skb dst
 480  * @skb: buffer
 481  * @dst: dst entry
 482  *
 483  * Sets skb dst, assuming a reference was taken on dst and should
 484  * be released by skb_dst_drop()
 485  */
 486 static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
 487 {
 488         skb->_skb_refdst = (unsigned long)dst;
 489 }
 490
 491 extern void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst);
 492
 493 /**
 494  * skb_dst_is_noref - Test if skb dst isn't refcounted
 495  * @skb: buffer
 496  */
 497 static inline bool skb_dst_is_noref(const struct sk_buff *skb)
 498 {
 499         return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
 500 }
 501
 502 static inline struct rtable *skb_rtable(const struct sk_buff *skb)
 503 {
 504         return (struct rtable *)skb_dst(skb);
 505 }
 506
 507 extern void kfree_skb(struct sk_buff *skb);
 508 extern void consume_skb(struct sk_buff *skb);
 509 extern void            __kfree_skb(struct sk_buff *skb);
 510 extern struct sk_buff *__alloc_skb(unsigned int size,
 511                                    gfp_t priority, int fclone, int node);
 512 static inline struct sk_buff *alloc_skb(unsigned int size,
 513                                         gfp_t priority)
 514 {
 515         return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
 516 }
 517
 518 static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
 519                                                gfp_t priority)
 520 {
 521         return __alloc_skb(size, priority, 1, NUMA_NO_NODE);
 522 }
 523
 524 extern bool skb_recycle_check(struct sk_buff *skb, int skb_size);
 525
 526 extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
 527 extern struct sk_buff *skb_clone(struct sk_buff *skb,
 528                                  gfp_t priority);
 529 extern struct sk_buff *skb_copy(const struct sk_buff *skb,
 530                                 gfp_t priority);
 531 extern struct sk_buff *pskb_copy(struct sk_buff *skb,
 532                                  gfp_t gfp_mask);
 533 extern int             pskb_expand_head(struct sk_buff *skb,
 534                                         int nhead, int ntail,
 535                                         gfp_t gfp_mask);
 536 extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
 537                                             unsigned int headroom);
 538 extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
 539                                        int newheadroom, int newtailroom,
 540                                        gfp_t priority);
 541 extern int             skb_to_sgvec(struct sk_buff *skb,
 542                                     struct scatterlist *sg, int offset,
 543                                     int len);
 544 extern int             skb_cow_data(struct sk_buff *skb, int tailbits,
 545                                     struct sk_buff **trailer);
 546 extern int             skb_pad(struct sk_buff *skb, int pad);
 547 #define dev_kfree_skb(a)        consume_skb(a)
 548
 549 extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
 550                         int getfrag(void *from, char *to, int offset,
 551                         int len,int odd, struct sk_buff *skb),
 552                         void *from, int length);
 553
 554 struct skb_seq_state {
 555         __u32           lower_offset;
 556         __u32           upper_offset;
 557         __u32           frag_idx;
 558         __u32           stepped_offset;
 559         struct sk_buff  *root_skb;
 560         struct sk_buff  *cur_skb;
 561         __u8            *frag_data;
 562 };
 563
 564 extern void           skb_prepare_seq_read(struct sk_buff *skb,
 565                                            unsigned int from, unsigned int to,
 566                                            struct skb_seq_state *st);
 567 extern unsigned int   skb_seq_read(unsigned int consumed, const u8 **data,
 568                                    struct skb_seq_state *st);
 569 extern void           skb_abort_seq_read(struct skb_seq_state *st);
 570
 571 extern unsigned int   skb_find_text(struct sk_buff *skb, unsigned int from,
 572                                     unsigned int to, struct ts_config *config,
 573                                     struct ts_state *state);
 574
 575 extern __u32 __skb_get_rxhash(struct sk_buff *skb);
 576 static inline __u32 skb_get_rxhash(struct sk_buff *skb)
 577 {
 578         if (!skb->rxhash)
 579                 skb->rxhash = __skb_get_rxhash(skb);
 580
 581         return skb->rxhash;
 582 }
 583
 584 #ifdef NET_SKBUFF_DATA_USES_OFFSET
 585 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
 586 {
 587         return skb->head + skb->end;
 588 }
 589 #else
 590 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
 591 {
 592         return skb->end;
 593 }
 594 #endif
 595
 596 /* Internal */
 597 #define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
 598
 599 static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb)
 600 {
 601         return &skb_shinfo(skb)->hwtstamps;
 602 }
 603
 604 /**
 605  *      skb_queue_empty - check if a queue is empty
 606  *      @list: queue head
 607  *
 608  *      Returns true if the queue is empty, false otherwise.
 609  */
 610 static inline int skb_queue_empty(const struct sk_buff_head *list)
 611 {
 612         return list->next == (struct sk_buff *)list;
 613 }
 614
 615 /**
 616  *      skb_queue_is_last - check if skb is the last entry in the queue
 617  *      @list: queue head
 618  *      @skb: buffer
 619  *
 620  *      Returns true if @skb is the last buffer on the list.
 621  */
 622 static inline bool skb_queue_is_last(const struct sk_buff_head *list,
 623                                      const struct sk_buff *skb)
 624 {
 625         return skb->next == (struct sk_buff *)list;
 626 }
 627
 628 /**
 629  *      skb_queue_is_first - check if skb is the first entry in the queue
 630  *      @list: queue head
 631  *      @skb: buffer
 632  *
 633  *      Returns true if @skb is the first buffer on the list.
 634  */
 635 static inline bool skb_queue_is_first(const struct sk_buff_head *list,
 636                                       const struct sk_buff *skb)
 637 {
 638         return skb->prev == (struct sk_buff *)list;
 639 }
 640
 641 /**
 642  *      skb_queue_next - return the next packet in the queue
 643  *      @list: queue head
 644  *      @skb: current buffer
 645  *
 646  *      Return the next packet in @list after @skb.  It is only valid to
 647  *      call this if skb_queue_is_last() evaluates to false.
 648  */
 649 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
 650                                              const struct sk_buff *skb)
 651 {
 652         /* This BUG_ON may seem severe, but if we just return then we
 653          * are going to dereference garbage.
 654          */
 655         BUG_ON(skb_queue_is_last(list, skb));
 656         return skb->next;
 657 }
 658
 659 /**
 660  *      skb_queue_prev - return the prev packet in the queue
 661  *      @list: queue head
 662  *      @skb: current buffer
 663  *
 664  *      Return the prev packet in @list before @skb.  It is only valid to
 665  *      call this if skb_queue_is_first() evaluates to false.
 666  */
 667 static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
 668                                              const struct sk_buff *skb)
 669 {
 670         /* This BUG_ON may seem severe, but if we just return then we
 671          * are going to dereference garbage.
 672          */
 673         BUG_ON(skb_queue_is_first(list, skb));
 674         return skb->prev;
 675 }
 676
 677 /**
 678  *      skb_get - reference buffer
 679  *      @skb: buffer to reference
 680  *
 681  *      Makes another reference to a socket buffer and returns a pointer
 682  *      to the buffer.
 683  */
 684 static inline struct sk_buff *skb_get(struct sk_buff *skb)
 685 {
 686         atomic_inc(&skb->users);
 687         return skb;
 688 }
 689
 690 /*
 691  * If users == 1, we are the only owner and are can avoid redundant
 692  * atomic change.
 693  */
 694
 695 /**
 696  *      skb_cloned - is the buffer a clone
 697  *      @skb: buffer to check
 698  *
 699  *      Returns true if the buffer was generated with skb_clone() and is
 700  *      one of multiple shared copies of the buffer. Cloned buffers are
 701  *      shared data so must not be written to under normal circumstances.
 702  */
 703 static inline int skb_cloned(const struct sk_buff *skb)
 704 {
 705         return skb->cloned &&
 706                (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
 707 }
 708
 709 /**
 710  *      skb_header_cloned - is the header a clone
 711  *      @skb: buffer to check
 712  *
 713  *      Returns true if modifying the header part of the buffer requires
 714  *      the data to be copied.
 715  */
 716 static inline int skb_header_cloned(const struct sk_buff *skb)
 717 {
 718         int dataref;
 719
 720         if (!skb->cloned)
 721                 return 0;
 722
 723         dataref = atomic_read(&skb_shinfo(skb)->dataref);
 724         dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
 725         return dataref != 1;
 726 }
 727
 728 /**
 729  *      skb_header_release - release reference to header
 730  *      @skb: buffer to operate on
 731  *
 732  *      Drop a reference to the header part of the buffer.  This is done
 733  *      by acquiring a payload reference.  You must not read from the header
 734  *      part of skb->data after this.
 735  */
 736 static inline void skb_header_release(struct sk_buff *skb)
 737 {
 738         BUG_ON(skb->nohdr);
 739         skb->nohdr = 1;
 740         atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
 741 }
 742
 743 /**
 744  *      skb_shared - is the buffer shared
 745  *      @skb: buffer to check
 746  *
 747  *      Returns true if more than one person has a reference to this
 748  *      buffer.
 749  */
 750 static inline int skb_shared(const struct sk_buff *skb)
 751 {
 752         return atomic_read(&skb->users) != 1;
 753 }
 754
 755 /**
 756  *      skb_share_check - check if buffer is shared and if so clone it
 757  *      @skb: buffer to check
 758  *      @pri: priority for memory allocation
 759  *
 760  *      If the buffer is shared the buffer is cloned and the old copy
 761  *      drops a reference. A new clone with a single reference is returned.
 762  *      If the buffer is not shared the original buffer is returned. When
 763  *      being called from interrupt status or with spinlocks held pri must
 764  *      be GFP_ATOMIC.
 765  *
 766  *      NULL is returned on a memory allocation failure.
 767  */
 768 static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
 769                                               gfp_t pri)
 770 {
 771         might_sleep_if(pri & __GFP_WAIT);
 772         if (skb_shared(skb)) {
 773                 struct sk_buff *nskb = skb_clone(skb, pri);
 774                 kfree_skb(skb);
 775                 skb = nskb;
 776         }
 777         return skb;
 778 }
 779
 780 /*
 781  *      Copy shared buffers into a new sk_buff. We effectively do COW on
 782  *      packets to handle cases where we have a local reader and forward
 783  *      and a couple of other messy ones. The normal one is tcpdumping
 784  *      a packet thats being forwarded.
 785  */
 786
 787 /**
 788  *      skb_unshare - make a copy of a shared buffer
 789  *      @skb: buffer to check
 790  *      @pri: priority for memory allocation
 791  *
 792  *      If the socket buffer is a clone then this function creates a new
 793  *      copy of the data, drops a reference count on the old copy and returns
 794  *      the new copy with the reference count at 1. If the buffer is not a clone
 795  *      the original buffer is returned. When called with a spinlock held or
 796  *      from interrupt state @pri must be %GFP_ATOMIC
 797  *
 798  *      %NULL is returned on a memory allocation failure.
 799  */
 800 static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
 801                                           gfp_t pri)
 802 {
 803         might_sleep_if(pri & __GFP_WAIT);
 804         if (skb_cloned(skb)) {
 805                 struct sk_buff *nskb = skb_copy(skb, pri);
 806                 kfree_skb(skb); /* Free our shared copy */
 807                 skb = nskb;
 808         }
 809         return skb;
 810 }
 811
 812 /**
 813  *      skb_peek - peek at the head of an &sk_buff_head
 814  *      @list_: list to peek at
 815  *
 816  *      Peek an &sk_buff. Unlike most other operations you _MUST_
 817  *      be careful with this one. A peek leaves the buffer on the
 818  *      list and someone else may run off with it. You must hold
 819  *      the appropriate locks or have a private queue to do this.
 820  *
 821  *      Returns %NULL for an empty list or a pointer to the head element.
 822  *      The reference count is not incremented and the reference is therefore
 823  *      volatile. Use with caution.
 824  */
 825 static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
 826 {
 827         struct sk_buff *list = ((struct sk_buff *)list_)->next;
 828         if (list == (struct sk_buff *)list_)
 829                 list = NULL;
 830         return list;
 831 }
 832
 833 /**
 834  *      skb_peek_tail - peek at the tail of an &sk_buff_head
 835  *      @list_: list to peek at
 836  *
 837  *      Peek an &sk_buff. Unlike most other operations you _MUST_
 838  *      be careful with this one. A peek leaves the buffer on the
 839  *      list and someone else may run off with it. You must hold
 840  *      the appropriate locks or have a private queue to do this.
 841  *
 842  *      Returns %NULL for an empty list or a pointer to the tail element.
 843  *      The reference count is not incremented and the reference is therefore
 844  *      volatile. Use with caution.
 845  */
 846 static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
 847 {
 848         struct sk_buff *list = ((struct sk_buff *)list_)->prev;
 849         if (list == (struct sk_buff *)list_)
 850                 list = NULL;
 851         return list;
 852 }
 853
 854 /**
 855  *      skb_queue_len   - get queue length
 856  *      @list_: list to measure
 857  *
 858  *      Return the length of an &sk_buff queue.
 859  */
 860 static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
 861 {
 862         return list_->qlen;
 863 }
 864
 865 /**
 866  *      __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
 867  *      @list: queue to initialize
 868  *
 869  *      This initializes only the list and queue length aspects of
 870  *      an sk_buff_head object.  This allows to initialize the list
 871  *      aspects of an sk_buff_head without reinitializing things like
 872  *      the spinlock.  It can also be used for on-stack sk_buff_head
 873  *      objects where the spinlock is known to not be used.
 874  */
 875 static inline void __skb_queue_head_init(struct sk_buff_head *list)
 876 {
 877         list->prev = list->next = (struct sk_buff *)list;
 878         list->qlen = 0;
 879 }
 880
 881 /*
 882  * This function creates a split out lock class for each invocation;
 883  * this is needed for now since a whole lot of users of the skb-queue
 884  * infrastructure in drivers have different locking usage (in hardirq)
 885  * than the networking core (in softirq only). In the long run either the
 886  * network layer or drivers should need annotation to consolidate the
 887  * main types of usage into 3 classes.
 888  */
 889 static inline void skb_queue_head_init(struct sk_buff_head *list)
 890 {
 891         spin_lock_init(&list->lock);
 892         __skb_queue_head_init(list);
 893 }
 894
 895 static inline void skb_queue_head_init_class(struct sk_buff_head *list,
 896                 struct lock_class_key *class)
 897 {
 898         skb_queue_head_init(list);
 899         lockdep_set_class(&list->lock, class);
 900 }
 901
 902 /*
 903  *      Insert an sk_buff on a list.
 904  *
 905  *      The "__skb_xxxx()" functions are the non-atomic ones that
 906  *      can only be called with interrupts disabled.
 907  */
 908 extern void        skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
 909 static inline void __skb_insert(struct sk_buff *newsk,
 910                                 struct sk_buff *prev, struct sk_buff *next,
 911                                 struct sk_buff_head *list)
 912 {
 913         newsk->next = next;
 914         newsk->prev = prev;
 915         next->prev  = prev->next = newsk;
 916         list->qlen++;
 917 }
 918
 919 static inline void __skb_queue_splice(const struct sk_buff_head *list,
 920                                       struct sk_buff *prev,
 921                                       struct sk_buff *next)
 922 {
 923         struct sk_buff *first = list->next;
 924         struct sk_buff *last = list->prev;
 925
 926         first->prev = prev;
 927         prev->next = first;
 928
 929         last->next = next;
 930         next->prev = last;
 931 }
 932
 933 /**
 934  *      skb_queue_splice - join two skb lists, this is designed for stacks
 935  *      @list: the new list to add
 936  *      @head: the place to add it in the first list
 937  */
 938 static inline void skb_queue_splice(const struct sk_buff_head *list,
 939                                     struct sk_buff_head *head)
 940 {
 941         if (!skb_queue_empty(list)) {
 942                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
 943                 head->qlen += list->qlen;
 944         }
 945 }
 946
 947 /**
 948  *      skb_queue_splice - join two skb lists and reinitialise the emptied list
 949  *      @list: the new list to add
 950  *      @head: the place to add it in the first list
 951  *
 952  *      The list at @list is reinitialised
 953  */
 954 static inline void skb_queue_splice_init(struct sk_buff_head *list,
 955                                          struct sk_buff_head *head)
 956 {
 957         if (!skb_queue_empty(list)) {
 958                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
 959                 head->qlen += list->qlen;
 960                 __skb_queue_head_init(list);
 961         }
 962 }
 963
 964 /**
 965  *      skb_queue_splice_tail - join two skb lists, each list being a queue
 966  *      @list: the new list to add
 967  *      @head: the place to add it in the first list
 968  */
 969 static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
 970                                          struct sk_buff_head *head)
 971 {
 972         if (!skb_queue_empty(list)) {
 973                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
 974                 head->qlen += list->qlen;
 975         }
 976 }
 977
 978 /**
 979  *      skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
 980  *      @list: the new list to add
 981  *      @head: the place to add it in the first list
 982  *
 983  *      Each of the lists is a queue.
 984  *      The list at @list is reinitialised
 985  */
 986 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
 987                                               struct sk_buff_head *head)
 988 {
 989         if (!skb_queue_empty(list)) {
 990                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
 991                 head->qlen += list->qlen;
 992                 __skb_queue_head_init(list);
 993         }
 994 }
 995
 996 /**
 997  *      __skb_queue_after - queue a buffer at the list head
 998  *      @list: list to use
 999  *      @prev: place after this buffer
1000  *      @newsk: buffer to queue
1001  *
1002  *      Queue a buffer int the middle of a list. This function takes no locks
1003  *      and you must therefore hold required locks before calling it.
1004  *
1005  *      A buffer cannot be placed on two lists at the same time.
1006  */
1007 static inline void __skb_queue_after(struct sk_buff_head *list,
1008                                      struct sk_buff *prev,
1009                                      struct sk_buff *newsk)
1010 {
1011         __skb_insert(newsk, prev, prev->next, list);
1012 }
1013
1014 extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
1015                        struct sk_buff_head *list);
1016
1017 static inline void __skb_queue_before(struct sk_buff_head *list,
1018                                       struct sk_buff *next,
1019                                       struct sk_buff *newsk)
1020 {
1021         __skb_insert(newsk, next->prev, next, list);
1022 }
1023
1024 /**
1025  *      __skb_queue_head - queue a buffer at the list head
1026  *      @list: list to use
1027  *      @newsk: buffer to queue
1028  *
1029  *      Queue a buffer at the start of a list. This function takes no locks
1030  *      and you must therefore hold required locks before calling it.
1031  *
1032  *      A buffer cannot be placed on two lists at the same time.
1033  */
1034 extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
1035 static inline void __skb_queue_head(struct sk_buff_head *list,
1036                                     struct sk_buff *newsk)
1037 {
1038         __skb_queue_after(list, (struct sk_buff *)list, newsk);
1039 }
1040
1041 /**
1042  *      __skb_queue_tail - queue a buffer at the list tail
1043  *      @list: list to use
1044  *      @newsk: buffer to queue
1045  *
1046  *      Queue a buffer at the end of a list. This function takes no locks
1047  *      and you must therefore hold required locks before calling it.
1048  *
1049  *      A buffer cannot be placed on two lists at the same time.
1050  */
1051 extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
1052 static inline void __skb_queue_tail(struct sk_buff_head *list,
1053                                    struct sk_buff *newsk)
1054 {
1055         __skb_queue_before(list, (struct sk_buff *)list, newsk);
1056 }
1057
1058 /*
1059  * remove sk_buff from list. _Must_ be called atomically, and with
1060  * the list known..
1061  */
1062 extern void        skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
1063 static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
1064 {
1065         struct sk_buff *next, *prev;
1066
1067         list->qlen--;
1068         next       = skb->next;
1069         prev       = skb->prev;
1070         skb->next  = skb->prev = NULL;
1071         next->prev = prev;
1072         prev->next = next;
1073 }
1074
1075 /**
1076  *      __skb_dequeue - remove from the head of the queue
1077  *      @list: list to dequeue from
1078  *
1079  *      Remove the head of the list. This function does not take any locks
1080  *      so must be used with appropriate locks held only. The head item is
1081  *      returned or %NULL if the list is empty.
1082  */
1083 extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
1084 static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
1085 {
1086         struct sk_buff *skb = skb_peek(list);
1087         if (skb)
1088                 __skb_unlink(skb, list);
1089         return skb;
1090 }
1091
1092 /**
1093  *      __skb_dequeue_tail - remove from the tail of the queue
1094  *      @list: list to dequeue from
1095  *
1096  *      Remove the tail of the list. This function does not take any locks
1097  *      so must be used with appropriate locks held only. The tail item is
1098  *      returned or %NULL if the list is empty.
1099  */
1100 extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
1101 static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
1102 {
1103         struct sk_buff *skb = skb_peek_tail(list);
1104         if (skb)
1105                 __skb_unlink(skb, list);
1106         return skb;
1107 }
1108
1109
1110 static inline int skb_is_nonlinear(const struct sk_buff *skb)
1111 {
1112         return skb->data_len;
1113 }
1114
1115 static inline unsigned int skb_headlen(const struct sk_buff *skb)
1116 {
1117         return skb->len - skb->data_len;
1118 }
1119
1120 static inline int skb_pagelen(const struct sk_buff *skb)
1121 {
1122         int i, len = 0;
1123
1124         for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
1125                 len += skb_shinfo(skb)->frags[i].size;
1126         return len + skb_headlen(skb);
1127 }
1128
1129 static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
1130                                       struct page *page, int off, int size)
1131 {
1132         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1133
1134         frag->page                = page;
1135         frag->page_offset         = off;
1136         frag->size                = size;
1137         skb_shinfo(skb)->nr_frags = i + 1;
1138 }
1139
1140 extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
1141                             int off, int size);
1142
1143 #define SKB_PAGE_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->nr_frags)
1144 #define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_has_frag_list(skb))
1145 #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
1146
1147 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1148 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1149 {
1150         return skb->head + skb->tail;
1151 }
1152
1153 static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1154 {
1155         skb->tail = skb->data - skb->head;
1156 }
1157
1158 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1159 {
1160         skb_reset_tail_pointer(skb);
1161         skb->tail += offset;
1162 }
1163 #else /* NET_SKBUFF_DATA_USES_OFFSET */
1164 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1165 {
1166         return skb->tail;
1167 }
1168
1169 static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1170 {
1171         skb->tail = skb->data;
1172 }
1173
1174 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1175 {
1176         skb->tail = skb->data + offset;
1177 }
1178
1179 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1180
1181 /*
1182  *      Add data to an sk_buff
1183  */
1184 extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
1185 static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
1186 {
1187         unsigned char *tmp = skb_tail_pointer(skb);
1188         SKB_LINEAR_ASSERT(skb);
1189         skb->tail += len;
1190         skb->len  += len;
1191         return tmp;
1192 }
1193
1194 extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
1195 static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
1196 {
1197         skb->data -= len;
1198         skb->len  += len;
1199         return skb->data;
1200 }
1201
1202 extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
1203 static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
1204 {
1205         skb->len -= len;
1206         BUG_ON(skb->len < skb->data_len);
1207         return skb->data += len;
1208 }
1209
1210 static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len)
1211 {
1212         return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
1213 }
1214
1215 extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
1216
1217 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
1218 {
1219         if (len > skb_headlen(skb) &&
1220             !__pskb_pull_tail(skb, len - skb_headlen(skb)))
1221                 return NULL;
1222         skb->len -= len;
1223         return skb->data += len;
1224 }
1225
1226 static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
1227 {
1228         return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
1229 }
1230
1231 static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
1232 {
1233         if (likely(len <= skb_headlen(skb)))
1234                 return 1;
1235         if (unlikely(len > skb->len))
1236                 return 0;
1237         return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
1238 }
1239
1240 /**
1241  *      skb_headroom - bytes at buffer head
1242  *      @skb: buffer to check
1243  *
1244  *      Return the number of bytes of free space at the head of an &sk_buff.
1245  */
1246 static inline unsigned int skb_headroom(const struct sk_buff *skb)
1247 {
1248         return skb->data - skb->head;
1249 }
1250
1251 /**
1252  *      skb_tailroom - bytes at buffer end
1253  *      @skb: buffer to check
1254  *
1255  *      Return the number of bytes of free space at the tail of an sk_buff
1256  */
1257 static inline int skb_tailroom(const struct sk_buff *skb)
1258 {
1259         return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
1260 }
1261
1262 /**
1263  *      skb_reserve - adjust headroom
1264  *      @skb: buffer to alter
1265  *      @len: bytes to move
1266  *
1267  *      Increase the headroom of an empty &sk_buff by reducing the tail
1268  *      room. This is only allowed for an empty buffer.
1269  */
1270 static inline void skb_reserve(struct sk_buff *skb, int len)
1271 {
1272         skb->data += len;
1273         skb->tail += len;
1274 }
1275
1276 static inline void skb_reset_mac_len(struct sk_buff *skb)
1277 {
1278         skb->mac_len = skb->network_header - skb->mac_header;
1279 }
1280
1281 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1282 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1283 {
1284         return skb->head + skb->transport_header;
1285 }
1286
1287 static inline void skb_reset_transport_header(struct sk_buff *skb)
1288 {
1289         skb->transport_header = skb->data - skb->head;
1290 }
1291
1292 static inline void skb_set_transport_header(struct sk_buff *skb,
1293                                             const int offset)
1294 {
1295         skb_reset_transport_header(skb);
1296         skb->transport_header += offset;
1297 }
1298
1299 static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1300 {
1301         return skb->head + skb->network_header;
1302 }
1303
1304 static inline void skb_reset_network_header(struct sk_buff *skb)
1305 {
1306         skb->network_header = skb->data - skb->head;
1307 }
1308
1309 static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1310 {
1311         skb_reset_network_header(skb);
1312         skb->network_header += offset;
1313 }
1314
1315 static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1316 {
1317         return skb->head + skb->mac_header;
1318 }
1319
1320 static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1321 {
1322         return skb->mac_header != ~0U;
1323 }
1324
1325 static inline void skb_reset_mac_header(struct sk_buff *skb)
1326 {
1327         skb->mac_header = skb->data - skb->head;
1328 }
1329
1330 static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1331 {
1332         skb_reset_mac_header(skb);
1333         skb->mac_header += offset;
1334 }
1335
1336 #else /* NET_SKBUFF_DATA_USES_OFFSET */
1337
1338 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
1339 {
1340         return skb->transport_header;
1341 }
1342
1343 static inline void skb_reset_transport_header(struct sk_buff *skb)
1344 {
1345         skb->transport_header = skb->data;
1346 }
1347
1348 static inline void skb_set_transport_header(struct sk_buff *skb,
1349                                             const int offset)
1350 {
1351         skb->transport_header = skb->data + offset;
1352 }
1353
1354 static inline unsigned char *skb_network_header(const struct sk_buff *skb)
1355 {
1356         return skb->network_header;
1357 }
1358
1359 static inline void skb_reset_network_header(struct sk_buff *skb)
1360 {
1361         skb->network_header = skb->data;
1362 }
1363
1364 static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
1365 {
1366         skb->network_header = skb->data + offset;
1367 }
1368
1369 static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
1370 {
1371         return skb->mac_header;
1372 }
1373
1374 static inline int skb_mac_header_was_set(const struct sk_buff *skb)
1375 {
1376         return skb->mac_header != NULL;
1377 }
1378
1379 static inline void skb_reset_mac_header(struct sk_buff *skb)
1380 {
1381         skb->mac_header = skb->data;
1382 }
1383
1384 static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
1385 {
1386         skb->mac_header = skb->data + offset;
1387 }
1388 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1389
1390 static inline int skb_checksum_start_offset(const struct sk_buff *skb)
1391 {
1392         return skb->csum_start - skb_headroom(skb);
1393 }
1394
1395 static inline int skb_transport_offset(const struct sk_buff *skb)
1396 {
1397         return skb_transport_header(skb) - skb->data;
1398 }
1399
1400 static inline u32 skb_network_header_len(const struct sk_buff *skb)
1401 {
1402         return skb->transport_header - skb->network_header;
1403 }
1404
1405 static inline int skb_network_offset(const struct sk_buff *skb)
1406 {
1407         return skb_network_header(skb) - skb->data;
1408 }
1409
1410 static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len)
1411 {
1412         return pskb_may_pull(skb, skb_network_offset(skb) + len);
1413 }
1414
1415 /*
1416  * CPUs often take a performance hit when accessing unaligned memory
1417  * locations. The actual performance hit varies, it can be small if the
1418  * hardware handles it or large if we have to take an exception and fix it
1419  * in software.
1420  *
1421  * Since an ethernet header is 14 bytes network drivers often end up with
1422  * the IP header at an unaligned offset. The IP header can be aligned by
1423  * shifting the start of the packet by 2 bytes. Drivers should do this
1424  * with:
1425  *
1426  * skb_reserve(skb, NET_IP_ALIGN);
1427  *
1428  * The downside to this alignment of the IP header is that the DMA is now
1429  * unaligned. On some architectures the cost of an unaligned DMA is high
1430  * and this cost outweighs the gains made by aligning the IP header.
1431  *
1432  * Since this trade off varies between architectures, we allow NET_IP_ALIGN
1433  * to be overridden.
1434  */
1435 #ifndef NET_IP_ALIGN
1436 #define NET_IP_ALIGN    2
1437 #endif
1438
1439 /*
1440  * The networking layer reserves some headroom in skb data (via
1441  * dev_alloc_skb). This is used to avoid having to reallocate skb data when
1442  * the header has to grow. In the default case, if the header has to grow
1443  * 32 bytes or less we avoid the reallocation.
1444  *
1445  * Unfortunately this headroom changes the DMA alignment of the resulting
1446  * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
1447  * on some architectures. An architecture can override this value,
1448  * perhaps setting it to a cacheline in size (since that will maintain
1449  * cacheline alignment of the DMA). It must be a power of 2.
1450  *
1451  * Various parts of the networking layer expect at least 32 bytes of
1452  * headroom, you should not reduce this.
1453  *
1454  * Using max(32, L1_CACHE_BYTES) makes sense (especially with RPS)
1455  * to reduce average number of cache lines per packet.
1456  * get_rps_cpus() for example only access one 64 bytes aligned block :
1457  * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8)
1458  */
1459 #ifndef NET_SKB_PAD
1460 #define NET_SKB_PAD     max(32, L1_CACHE_BYTES)
1461 #endif
1462
1463 extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
1464
1465 static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
1466 {
1467         if (unlikely(skb_is_nonlinear(skb))) {
1468                 WARN_ON(1);
1469                 return;
1470         }
1471         skb->len = len;
1472         skb_set_tail_pointer(skb, len);
1473 }
1474
1475 extern void skb_trim(struct sk_buff *skb, unsigned int len);
1476
1477 static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
1478 {
1479         if (skb->data_len)
1480                 return ___pskb_trim(skb, len);
1481         __skb_trim(skb, len);
1482         return 0;
1483 }
1484
1485 static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
1486 {
1487         return (len < skb->len) ? __pskb_trim(skb, len) : 0;
1488 }
1489
1490 /**
1491  *      pskb_trim_unique - remove end from a paged unique (not cloned) buffer
1492  *      @skb: buffer to alter
1493  *      @len: new length
1494  *
1495  *      This is identical to pskb_trim except that the caller knows that
1496  *      the skb is not cloned so we should never get an error due to out-
1497  *      of-memory.
1498  */
1499 static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
1500 {
1501         int err = pskb_trim(skb, len);
1502         BUG_ON(err);
1503 }
1504
1505 /**
1506  *      skb_orphan - orphan a buffer
1507  *      @skb: buffer to orphan
1508  *
1509  *      If a buffer currently has an owner then we call the owner's
1510  *      destructor function and make the @skb unowned. The buffer continues
1511  *      to exist but is no longer charged to its former owner.
1512  */
1513 static inline void skb_orphan(struct sk_buff *skb)
1514 {
1515         if (skb->destructor)
1516                 skb->destructor(skb);
1517         skb->destructor = NULL;
1518         skb->sk         = NULL;
1519 }
1520
1521 /**
1522  *      __skb_queue_purge - empty a list
1523  *      @list: list to empty
1524  *
1525  *      Delete all buffers on an &sk_buff list. Each buffer is removed from
1526  *      the list and one reference dropped. This function does not take the
1527  *      list lock and the caller must hold the relevant locks to use it.
1528  */
1529 extern void skb_queue_purge(struct sk_buff_head *list);
1530 static inline void __skb_queue_purge(struct sk_buff_head *list)
1531 {
1532         struct sk_buff *skb;
1533         while ((skb = __skb_dequeue(list)) != NULL)
1534                 kfree_skb(skb);
1535 }
1536
1537 /**
1538  *      __dev_alloc_skb - allocate an skbuff for receiving
1539  *      @length: length to allocate
1540  *      @gfp_mask: get_free_pages mask, passed to alloc_skb
1541  *
1542  *      Allocate a new &sk_buff and assign it a usage count of one. The
1543  *      buffer has unspecified headroom built in. Users should allocate
1544  *      the headroom they think they need without accounting for the
1545  *      built in space. The built in space is used for optimisations.
1546  *
1547  *      %NULL is returned if there is no free memory.
1548  */
1549 static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
1550                                               gfp_t gfp_mask)
1551 {
1552         struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
1553         if (likely(skb))
1554                 skb_reserve(skb, NET_SKB_PAD);
1555         return skb;
1556 }
1557
1558 extern struct sk_buff *dev_alloc_skb(unsigned int length);
1559
1560 extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
1561                 unsigned int length, gfp_t gfp_mask);
1562
1563 /**
1564  *      netdev_alloc_skb - allocate an skbuff for rx on a specific device
1565  *      @dev: network device to receive on
1566  *      @length: length to allocate
1567  *
1568  *      Allocate a new &sk_buff and assign it a usage count of one. The
1569  *      buffer has unspecified headroom built in. Users should allocate
1570  *      the headroom they think they need without accounting for the
1571  *      built in space. The built in space is used for optimisations.
1572  *
1573  *      %NULL is returned if there is no free memory. Although this function
1574  *      allocates memory it can be called from an interrupt.
1575  */
1576 static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
1577                 unsigned int length)
1578 {
1579         return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
1580 }
1581
1582 static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
1583                 unsigned int length, gfp_t gfp)
1584 {
1585         struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
1586
1587         if (NET_IP_ALIGN && skb)
1588                 skb_reserve(skb, NET_IP_ALIGN);
1589         return skb;
1590 }
1591
1592 static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
1593                 unsigned int length)
1594 {
1595         return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
1596 }
1597
1598 /**
1599  *      __netdev_alloc_page - allocate a page for ps-rx on a specific device
1600  *      @dev: network device to receive on
1601  *      @gfp_mask: alloc_pages_node mask
1602  *
1603  *      Allocate a new page. dev currently unused.
1604  *
1605  *      %NULL is returned if there is no free memory.
1606  */
1607 static inline struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask)
1608 {
1609         return alloc_pages_node(NUMA_NO_NODE, gfp_mask, 0);
1610 }
1611
1612 /**
1613  *      netdev_alloc_page - allocate a page for ps-rx on a specific device
1614  *      @dev: network device to receive on
1615  *
1616  *      Allocate a new page. dev currently unused.
1617  *
1618  *      %NULL is returned if there is no free memory.
1619  */
1620 static inline struct page *netdev_alloc_page(struct net_device *dev)
1621 {
1622         return __netdev_alloc_page(dev, GFP_ATOMIC);
1623 }
1624
1625 static inline void netdev_free_page(struct net_device *dev, struct page *page)
1626 {
1627         __free_page(page);
1628 }
1629
1630 /**
1631  *      skb_clone_writable - is the header of a clone writable
1632  *      @skb: buffer to check
1633  *      @len: length up to which to write
1634  *
1635  *      Returns true if modifying the header part of the cloned buffer
1636  *      does not requires the data to be copied.
1637  */
1638 static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len)
1639 {
1640         return !skb_header_cloned(skb) &&
1641                skb_headroom(skb) + len <= skb->hdr_len;
1642 }
1643
1644 static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
1645                             int cloned)
1646 {
1647         int delta = 0;
1648
1649         if (headroom < NET_SKB_PAD)
1650                 headroom = NET_SKB_PAD;
1651         if (headroom > skb_headroom(skb))
1652                 delta = headroom - skb_headroom(skb);
1653
1654         if (delta || cloned)
1655                 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
1656                                         GFP_ATOMIC);
1657         return 0;
1658 }
1659
1660 /**
1661  *      skb_cow - copy header of skb when it is required
1662  *      @skb: buffer to cow
1663  *      @headroom: needed headroom
1664  *
1665  *      If the skb passed lacks sufficient headroom or its data part
1666  *      is shared, data is reallocated. If reallocation fails, an error
1667  *      is returned and original skb is not changed.
1668  *
1669  *      The result is skb with writable area skb->head...skb->tail
1670  *      and at least @headroom of space at head.
1671  */
1672 static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
1673 {
1674         return __skb_cow(skb, headroom, skb_cloned(skb));
1675 }
1676
1677 /**
1678  *      skb_cow_head - skb_cow but only making the head writable
1679  *      @skb: buffer to cow
1680  *      @headroom: needed headroom
1681  *
1682  *      This function is identical to skb_cow except that we replace the
1683  *      skb_cloned check by skb_header_cloned.  It should be used when
1684  *      you only need to push on some header and do not need to modify
1685  *      the data.
1686  */
1687 static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
1688 {
1689         return __skb_cow(skb, headroom, skb_header_cloned(skb));
1690 }
1691
1692 /**
1693  *      skb_padto       - pad an skbuff up to a minimal size
1694  *      @skb: buffer to pad
1695  *      @len: minimal length
1696  *
1697  *      Pads up a buffer to ensure the trailing bytes exist and are
1698  *      blanked. If the buffer already contains sufficient data it
1699  *      is untouched. Otherwise it is extended. Returns zero on
1700  *      success. The skb is freed on error.
1701  */
1702
1703 static inline int skb_padto(struct sk_buff *skb, unsigned int len)
1704 {
1705         unsigned int size = skb->len;
1706         if (likely(size >= len))
1707                 return 0;
1708         return skb_pad(skb, len - size);
1709 }
1710
1711 static inline int skb_add_data(struct sk_buff *skb,
1712                                char __user *from, int copy)
1713 {
1714         const int off = skb->len;
1715
1716         if (skb->ip_summed == CHECKSUM_NONE) {
1717                 int err = 0;
1718                 __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
1719                                                             copy, 0, &err);
1720                 if (!err) {
1721                         skb->csum = csum_block_add(skb->csum, csum, off);
1722                         return 0;
1723                 }
1724         } else if (!copy_from_user(skb_put(skb, copy), from, copy))
1725                 return 0;
1726
1727         __skb_trim(skb, off);
1728         return -EFAULT;
1729 }
1730
1731 static inline int skb_can_coalesce(struct sk_buff *skb, int i,
1732                                    struct page *page, int off)
1733 {
1734         if (i) {
1735                 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
1736
1737                 return page == frag->page &&
1738                        off == frag->page_offset + frag->size;
1739         }
1740         return 0;
1741 }
1742
1743 static inline int __skb_linearize(struct sk_buff *skb)
1744 {
1745         return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
1746 }
1747
1748 /**
1749  *      skb_linearize - convert paged skb to linear one
1750  *      @skb: buffer to linarize
1751  *
1752  *      If there is no free memory -ENOMEM is returned, otherwise zero
1753  *      is returned and the old skb data released.
1754  */
1755 static inline int skb_linearize(struct sk_buff *skb)
1756 {
1757         return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
1758 }
1759
1760 /**
1761  *      skb_linearize_cow - make sure skb is linear and writable
1762  *      @skb: buffer to process
1763  *
1764  *      If there is no free memory -ENOMEM is returned, otherwise zero
1765  *      is returned and the old skb data released.
1766  */
1767 static inline int skb_linearize_cow(struct sk_buff *skb)
1768 {
1769         return skb_is_nonlinear(skb) || skb_cloned(skb) ?
1770                __skb_linearize(skb) : 0;
1771 }
1772
1773 /**
1774  *      skb_postpull_rcsum - update checksum for received skb after pull
1775  *      @skb: buffer to update
1776  *      @start: start of data before pull
1777  *      @len: length of data pulled
1778  *
1779  *      After doing a pull on a received packet, you need to call this to
1780  *      update the CHECKSUM_COMPLETE checksum, or set ip_summed to
1781  *      CHECKSUM_NONE so that it can be recomputed from scratch.
1782  */
1783
1784 static inline void skb_postpull_rcsum(struct sk_buff *skb,
1785                                       const void *start, unsigned int len)
1786 {
1787         if (skb->ip_summed == CHECKSUM_COMPLETE)
1788                 skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
1789 }
1790
1791 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
1792
1793 /**
1794  *      pskb_trim_rcsum - trim received skb and update checksum
1795  *      @skb: buffer to trim
1796  *      @len: new length
1797  *
1798  *      This is exactly the same as pskb_trim except that it ensures the
1799  *      checksum of received packets are still valid after the operation.
1800  */
1801
1802 static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
1803 {
1804         if (likely(len >= skb->len))
1805                 return 0;
1806         if (skb->ip_summed == CHECKSUM_COMPLETE)
1807                 skb->ip_summed = CHECKSUM_NONE;
1808         return __pskb_trim(skb, len);
1809 }
1810
1811 #define skb_queue_walk(queue, skb) \
1812                 for (skb = (queue)->next;                                       \
1813                      skb != (struct sk_buff *)(queue);                          \
1814                      skb = skb->next)
1815
1816 #define skb_queue_walk_safe(queue, skb, tmp)                                    \
1817                 for (skb = (queue)->next, tmp = skb->next;                      \
1818                      skb != (struct sk_buff *)(queue);                          \
1819                      skb = tmp, tmp = skb->next)
1820
1821 #define skb_queue_walk_from(queue, skb)                                         \
1822                 for (; skb != (struct sk_buff *)(queue);                        \
1823                      skb = skb->next)
1824
1825 #define skb_queue_walk_from_safe(queue, skb, tmp)                               \
1826                 for (tmp = skb->next;                                           \
1827                      skb != (struct sk_buff *)(queue);                          \
1828                      skb = tmp, tmp = skb->next)
1829
1830 #define skb_queue_reverse_walk(queue, skb) \
1831                 for (skb = (queue)->prev;                                       \
1832                      skb != (struct sk_buff *)(queue);                          \
1833                      skb = skb->prev)
1834
1835 #define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
1836                 for (skb = (queue)->prev, tmp = skb->prev;                      \
1837                      skb != (struct sk_buff *)(queue);                          \
1838                      skb = tmp, tmp = skb->prev)
1839
1840 #define skb_queue_reverse_walk_from_safe(queue, skb, tmp)                       \
1841                 for (tmp = skb->prev;                                           \
1842                      skb != (struct sk_buff *)(queue);                          \
1843                      skb = tmp, tmp = skb->prev)
1844
1845 static inline bool skb_has_frag_list(const struct sk_buff *skb)
1846 {
1847         return skb_shinfo(skb)->frag_list != NULL;
1848 }
1849
1850 static inline void skb_frag_list_init(struct sk_buff *skb)
1851 {
1852         skb_shinfo(skb)->frag_list = NULL;
1853 }
1854
1855 static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag)
1856 {
1857         frag->next = skb_shinfo(skb)->frag_list;
1858         skb_shinfo(skb)->frag_list = frag;
1859 }
1860
1861 #define skb_walk_frags(skb, iter)       \
1862         for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
1863
1864 extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
1865                                            int *peeked, int *err);
1866 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
1867                                          int noblock, int *err);
1868 extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
1869                                      struct poll_table_struct *wait);
1870 extern int             skb_copy_datagram_iovec(const struct sk_buff *from,
1871                                                int offset, struct iovec *to,
1872                                                int size);
1873 extern int             skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
1874                                                         int hlen,
1875                                                         struct iovec *iov);
1876 extern int             skb_copy_datagram_from_iovec(struct sk_buff *skb,
1877                                                     int offset,
1878                                                     const struct iovec *from,
1879                                                     int from_offset,
1880                                                     int len);
1881 extern int             skb_copy_datagram_const_iovec(const struct sk_buff *from,
1882                                                      int offset,
1883                                                      const struct iovec *to,
1884                                                      int to_offset,
1885                                                      int size);
1886 extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
1887 extern void            skb_free_datagram_locked(struct sock *sk,
1888                                                 struct sk_buff *skb);
1889 extern int             skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
1890                                          unsigned int flags);
1891 extern __wsum          skb_checksum(const struct sk_buff *skb, int offset,
1892                                     int len, __wsum csum);
1893 extern int             skb_copy_bits(const struct sk_buff *skb, int offset,
1894                                      void *to, int len);
1895 extern int             skb_store_bits(struct sk_buff *skb, int offset,
1896                                       const void *from, int len);
1897 extern __wsum          skb_copy_and_csum_bits(const struct sk_buff *skb,
1898                                               int offset, u8 *to, int len,
1899                                               __wsum csum);
1900 extern int             skb_splice_bits(struct sk_buff *skb,
1901                                                 unsigned int offset,
1902                                                 struct pipe_inode_info *pipe,
1903                                                 unsigned int len,
1904                                                 unsigned int flags);
1905 extern void            skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
1906 extern void            skb_split(struct sk_buff *skb,
1907                                  struct sk_buff *skb1, const u32 len);
1908 extern int             skb_shift(struct sk_buff *tgt, struct sk_buff *skb,
1909                                  int shiftlen);
1910
1911 extern struct sk_buff *skb_segment(struct sk_buff *skb, u32 features);
1912
1913 static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
1914                                        int len, void *buffer)
1915 {
1916         int hlen = skb_headlen(skb);
1917
1918         if (hlen - offset >= len)
1919                 return skb->data + offset;
1920
1921         if (skb_copy_bits(skb, offset, buffer, len) < 0)
1922                 return NULL;
1923
1924         return buffer;
1925 }
1926
1927 static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
1928                                              void *to,
1929                                              const unsigned int len)
1930 {
1931         memcpy(to, skb->data, len);
1932 }
1933
1934 static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
1935                                                     const int offset, void *to,
1936                                                     const unsigned int len)
1937 {
1938         memcpy(to, skb->data + offset, len);
1939 }
1940
1941 static inline void skb_copy_to_linear_data(struct sk_buff *skb,
1942                                            const void *from,
1943                                            const unsigned int len)
1944 {
1945         memcpy(skb->data, from, len);
1946 }
1947
1948 static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
1949                                                   const int offset,
1950                                                   const void *from,
1951                                                   const unsigned int len)
1952 {
1953         memcpy(skb->data + offset, from, len);
1954 }
1955
1956 extern void skb_init(void);
1957
1958 static inline ktime_t skb_get_ktime(const struct sk_buff *skb)
1959 {
1960         return skb->tstamp;
1961 }
1962
1963 /**
1964  *      skb_get_timestamp - get timestamp from a skb
1965  *      @skb: skb to get stamp from
1966  *      @stamp: pointer to struct timeval to store stamp in
1967  *
1968  *      Timestamps are stored in the skb as offsets to a base timestamp.
1969  *      This function converts the offset back to a struct timeval and stores
1970  *      it in stamp.
1971  */
1972 static inline void skb_get_timestamp(const struct sk_buff *skb,
1973                                      struct timeval *stamp)
1974 {
1975         *stamp = ktime_to_timeval(skb->tstamp);
1976 }
1977
1978 static inline void skb_get_timestampns(const struct sk_buff *skb,
1979                                        struct timespec *stamp)
1980 {
1981         *stamp = ktime_to_timespec(skb->tstamp);
1982 }
1983
1984 static inline void __net_timestamp(struct sk_buff *skb)
1985 {
1986         skb->tstamp = ktime_get_real();
1987 }
1988
1989 static inline ktime_t net_timedelta(ktime_t t)
1990 {
1991         return ktime_sub(ktime_get_real(), t);
1992 }
1993
1994 static inline ktime_t net_invalid_timestamp(void)
1995 {
1996         return ktime_set(0, 0);
1997 }
1998
1999 extern void skb_timestamping_init(void);
2000
2001 #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
2002
2003 extern void skb_clone_tx_timestamp(struct sk_buff *skb);
2004 extern bool skb_defer_rx_timestamp(struct sk_buff *skb);
2005
2006 #else /* CONFIG_NETWORK_PHY_TIMESTAMPING */
2007
2008 static inline void skb_clone_tx_timestamp(struct sk_buff *skb)
2009 {
2010 }
2011
2012 static inline bool skb_defer_rx_timestamp(struct sk_buff *skb)
2013 {
2014         return false;
2015 }
2016
2017 #endif /* !CONFIG_NETWORK_PHY_TIMESTAMPING */
2018
2019 /**
2020  * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps
2021  *
2022  * @skb: clone of the the original outgoing packet
2023  * @hwtstamps: hardware time stamps
2024  *
2025  */
2026 void skb_complete_tx_timestamp(struct sk_buff *skb,
2027                                struct skb_shared_hwtstamps *hwtstamps);
2028
2029 /**
2030  * skb_tstamp_tx - queue clone of skb with send time stamps
2031  * @orig_skb:   the original outgoing packet
2032  * @hwtstamps:  hardware time stamps, may be NULL if not available
2033  *
2034  * If the skb has a socket associated, then this function clones the
2035  * skb (thus sharing the actual data and optional structures), stores
2036  * the optional hardware time stamping information (if non NULL) or
2037  * generates a software time stamp (otherwise), then queues the clone
2038  * to the error queue of the socket.  Errors are silently ignored.
2039  */
2040 extern void skb_tstamp_tx(struct sk_buff *orig_skb,
2041                         struct skb_shared_hwtstamps *hwtstamps);
2042
2043 static inline void sw_tx_timestamp(struct sk_buff *skb)
2044 {
2045         if (skb_shinfo(skb)->tx_flags & SKBTX_SW_TSTAMP &&
2046             !(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
2047                 skb_tstamp_tx(skb, NULL);
2048 }
2049
2050 /**
2051  * skb_tx_timestamp() - Driver hook for transmit timestamping
2052  *
2053  * Ethernet MAC Drivers should call this function in their hard_xmit()
2054  * function immediately before giving the sk_buff to the MAC hardware.
2055  *
2056  * @skb: A socket buffer.
2057  */
2058 static inline void skb_tx_timestamp(struct sk_buff *skb)
2059 {
2060         skb_clone_tx_timestamp(skb);
2061         sw_tx_timestamp(skb);
2062 }
2063
2064 extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
2065 extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
2066
2067 static inline int skb_csum_unnecessary(const struct sk_buff *skb)
2068 {
2069         return skb->ip_summed & CHECKSUM_UNNECESSARY;
2070 }
2071
2072 /**
2073  *      skb_checksum_complete - Calculate checksum of an entire packet
2074  *      @skb: packet to process
2075  *
2076  *      This function calculates the checksum over the entire packet plus
2077  *      the value of skb->csum.  The latter can be used to supply the
2078  *      checksum of a pseudo header as used by TCP/UDP.  It returns the
2079  *      checksum.
2080  *
2081  *      For protocols that contain complete checksums such as ICMP/TCP/UDP,
2082  *      this function can be used to verify that checksum on received
2083  *      packets.  In that case the function should return zero if the
2084  *      checksum is correct.  In particular, this function will return zero
2085  *      if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
2086  *      hardware has already verified the correctness of the checksum.
2087  */
2088 static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
2089 {
2090         return skb_csum_unnecessary(skb) ?
2091                0 : __skb_checksum_complete(skb);
2092 }
2093
2094 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
2095 extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
2096 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
2097 {
2098         if (nfct && atomic_dec_and_test(&nfct->use))
2099                 nf_conntrack_destroy(nfct);
2100 }
2101 static inline void nf_conntrack_get(struct nf_conntrack *nfct)
2102 {
2103         if (nfct)
2104                 atomic_inc(&nfct->use);
2105 }
2106 #endif
2107 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
2108 static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
2109 {
2110         if (skb)
2111                 atomic_inc(&skb->users);
2112 }
2113 static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
2114 {
2115         if (skb)
2116                 kfree_skb(skb);
2117 }
2118 #endif
2119 #ifdef CONFIG_BRIDGE_NETFILTER
2120 static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
2121 {
2122         if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
2123                 kfree(nf_bridge);
2124 }
2125 static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
2126 {
2127         if (nf_bridge)
2128                 atomic_inc(&nf_bridge->use);
2129 }
2130 #endif /* CONFIG_BRIDGE_NETFILTER */
2131 static inline void nf_reset(struct sk_buff *skb)
2132 {
2133 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
2134         nf_conntrack_put(skb->nfct);
2135         skb->nfct = NULL;
2136 #endif
2137 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
2138         nf_conntrack_put_reasm(skb->nfct_reasm);
2139         skb->nfct_reasm = NULL;
2140 #endif
2141 #ifdef CONFIG_BRIDGE_NETFILTER
2142         nf_bridge_put(skb->nf_bridge);
2143         skb->nf_bridge = NULL;
2144 #endif
2145 }
2146
2147 /* Note: This doesn't put any conntrack and bridge info in dst. */
2148 static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2149 {
2150 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
2151         dst->nfct = src->nfct;
2152         nf_conntrack_get(src->nfct);
2153         dst->nfctinfo = src->nfctinfo;
2154 #endif
2155 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
2156         dst->nfct_reasm = src->nfct_reasm;
2157         nf_conntrack_get_reasm(src->nfct_reasm);
2158 #endif
2159 #ifdef CONFIG_BRIDGE_NETFILTER
2160         dst->nf_bridge  = src->nf_bridge;
2161         nf_bridge_get(src->nf_bridge);
2162 #endif
2163 }
2164
2165 static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
2166 {
2167 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
2168         nf_conntrack_put(dst->nfct);
2169 #endif
2170 #ifdef NET_SKBUFF_NF_DEFRAG_NEEDED
2171         nf_conntrack_put_reasm(dst->nfct_reasm);
2172 #endif
2173 #ifdef CONFIG_BRIDGE_NETFILTER
2174         nf_bridge_put(dst->nf_bridge);
2175 #endif
2176         __nf_copy(dst, src);
2177 }
2178
2179 #ifdef CONFIG_NETWORK_SECMARK
2180 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2181 {
2182         to->secmark = from->secmark;
2183 }
2184
2185 static inline void skb_init_secmark(struct sk_buff *skb)
2186 {
2187         skb->secmark = 0;
2188 }
2189 #else
2190 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
2191 { }
2192
2193 static inline void skb_init_secmark(struct sk_buff *skb)
2194 { }
2195 #endif
2196
2197 static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
2198 {
2199         skb->queue_mapping = queue_mapping;
2200 }
2201
2202 static inline u16 skb_get_queue_mapping(const struct sk_buff *skb)
2203 {
2204         return skb->queue_mapping;
2205 }
2206
2207 static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
2208 {
2209         to->queue_mapping = from->queue_mapping;
2210 }
2211
2212 static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue)
2213 {
2214         skb->queue_mapping = rx_queue + 1;
2215 }
2216
2217 static inline u16 skb_get_rx_queue(const struct sk_buff *skb)
2218 {
2219         return skb->queue_mapping - 1;
2220 }
2221
2222 static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
2223 {
2224         return skb->queue_mapping != 0;
2225 }
2226
2227 extern u16 __skb_tx_hash(const struct net_device *dev,
2228                          const struct sk_buff *skb,
2229                          unsigned int num_tx_queues);
2230
2231 #ifdef CONFIG_XFRM
2232 static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2233 {
2234         return skb->sp;
2235 }
2236 #else
2237 static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
2238 {
2239         return NULL;
2240 }
2241 #endif
2242
2243 static inline int skb_is_gso(const struct sk_buff *skb)
2244 {
2245         return skb_shinfo(skb)->gso_size;
2246 }
2247
2248 static inline int skb_is_gso_v6(const struct sk_buff *skb)
2249 {
2250         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
2251 }
2252
2253 extern void __skb_warn_lro_forwarding(const struct sk_buff *skb);
2254
2255 static inline bool skb_warn_if_lro(const struct sk_buff *skb)
2256 {
2257         /* LRO sets gso_size but not gso_type, whereas if GSO is really
2258          * wanted then gso_type will be set. */
2259         struct skb_shared_info *shinfo = skb_shinfo(skb);
2260         if (skb_is_nonlinear(skb) && shinfo->gso_size != 0 &&
2261             unlikely(shinfo->gso_type == 0)) {
2262                 __skb_warn_lro_forwarding(skb);
2263                 return true;
2264         }
2265         return false;
2266 }
2267
2268 static inline void skb_forward_csum(struct sk_buff *skb)
2269 {
2270         /* Unfortunately we don't support this one.  Any brave souls? */
2271         if (skb->ip_summed == CHECKSUM_COMPLETE)
2272                 skb->ip_summed = CHECKSUM_NONE;
2273 }
2274
2275 /**
2276  * skb_checksum_none_assert - make sure skb ip_summed is CHECKSUM_NONE
2277  * @skb: skb to check
2278  *
2279  * fresh skbs have their ip_summed set to CHECKSUM_NONE.
2280  * Instead of forcing ip_summed to CHECKSUM_NONE, we can
2281  * use this helper, to document places where we make this assertion.
2282  */
2283 static inline void skb_checksum_none_assert(struct sk_buff *skb)
2284 {
2285 #ifdef DEBUG
2286         BUG_ON(skb->ip_summed != CHECKSUM_NONE);
2287 #endif
2288 }
2289
2290 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
2291
2292 #endif  /* __KERNEL__ */
2293 #endif  /* _LINUX_SKBUFF_H */