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