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