~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/skbuff.h

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp