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