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