Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/include/linux/skbuff.h

  1 /*
  2  *      Definitions for the 'struct sk_buff' memory handlers.
  3  *
  4  *      Authors:
  5  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
  6  *              Florian La Roche, <rzsfl@rz.uni-sb.de>
  7  *
  8  *      This program is free software; you can redistribute it and/or
  9  *      modify it under the terms of the GNU General Public License
 10  *      as published by the Free Software Foundation; either version
 11  *      2 of the License, or (at your option) any later version.
 12  */
 13 
 14 #ifndef _LINUX_SKBUFF_H
 15 #define _LINUX_SKBUFF_H
 16 
 17 #include <linux/kernel.h>
 18 #include <linux/kmemcheck.h>
 19 #include <linux/compiler.h>
 20 #include <linux/time.h>
 21 #include <linux/bug.h>
 22 #include <linux/cache.h>
 23 #include <linux/rbtree.h>
 24 #include <linux/socket.h>
 25 
 26 #include <linux/atomic.h>
 27 #include <asm/types.h>
 28 #include <linux/spinlock.h>
 29 #include <linux/net.h>
 30 #include <linux/textsearch.h>
 31 #include <net/checksum.h>
 32 #include <linux/rcupdate.h>
 33 #include <linux/hrtimer.h>
 34 #include <linux/dma-mapping.h>
 35 #include <linux/netdev_features.h>
 36 #include <linux/sched.h>
 37 #include <net/flow_dissector.h>
 38 #include <linux/splice.h>
 39 #include <linux/in6.h>
 40 #include <linux/if_packet.h>
 41 #include <net/flow.h>
 42 
 43 /* The interface for checksum offload between the stack and networking drivers
 44  * is as follows...
 45  *
 46  * A. IP checksum related features
 47  *
 48  * Drivers advertise checksum offload capabilities in the features of a device.
 49  * From the stack's point of view these are capabilities offered by the driver,
 50  * a driver typically only advertises features that it is capable of offloading
 51  * to its device.
 52  *
 53  * The checksum related features are:
 54  *
 55  *      NETIF_F_HW_CSUM - The driver (or its device) is able to compute one
 56  *                        IP (one's complement) checksum for any combination
 57  *                        of protocols or protocol layering. The checksum is
 58  *                        computed and set in a packet per the CHECKSUM_PARTIAL
 59  *                        interface (see below).
 60  *
 61  *      NETIF_F_IP_CSUM - Driver (device) is only able to checksum plain
 62  *                        TCP or UDP packets over IPv4. These are specifically
 63  *                        unencapsulated packets of the form IPv4|TCP or
 64  *                        IPv4|UDP where the Protocol field in the IPv4 header
 65  *                        is TCP or UDP. The IPv4 header may contain IP options
 66  *                        This feature cannot be set in features for a device
 67  *                        with NETIF_F_HW_CSUM also set. This feature is being
 68  *                        DEPRECATED (see below).
 69  *
 70  *      NETIF_F_IPV6_CSUM - Driver (device) is only able to checksum plain
 71  *                        TCP or UDP packets over IPv6. These are specifically
 72  *                        unencapsulated packets of the form IPv6|TCP or
 73  *                        IPv4|UDP where the Next Header field in the IPv6
 74  *                        header is either TCP or UDP. IPv6 extension headers
 75  *                        are not supported with this feature. This feature
 76  *                        cannot be set in features for a device with
 77  *                        NETIF_F_HW_CSUM also set. This feature is being
 78  *                        DEPRECATED (see below).
 79  *
 80  *      NETIF_F_RXCSUM - Driver (device) performs receive checksum offload.
 81  *                       This flag is used only used to disable the RX checksum
 82  *                       feature for a device. The stack will accept receive
 83  *                       checksum indication in packets received on a device
 84  *                       regardless of whether NETIF_F_RXCSUM is set.
 85  *
 86  * B. Checksumming of received packets by device. Indication of checksum
 87  *    verification is in set skb->ip_summed. Possible values are:
 88  *
 89  * CHECKSUM_NONE:
 90  *
 91  *   Device did not checksum this packet e.g. due to lack of capabilities.
 92  *   The packet contains full (though not verified) checksum in packet but
 93  *   not in skb->csum. Thus, skb->csum is undefined in this case.
 94  *
 95  * CHECKSUM_UNNECESSARY:
 96  *
 97  *   The hardware you're dealing with doesn't calculate the full checksum
 98  *   (as in CHECKSUM_COMPLETE), but it does parse headers and verify checksums
 99  *   for specific protocols. For such packets it will set CHECKSUM_UNNECESSARY
100  *   if their checksums are okay. skb->csum is still undefined in this case
101  *   though. A driver or device must never modify the checksum field in the
102  *   packet even if checksum is verified.
103  *
104  *   CHECKSUM_UNNECESSARY is applicable to following protocols:
105  *     TCP: IPv6 and IPv4.
106  *     UDP: IPv4 and IPv6. A device may apply CHECKSUM_UNNECESSARY to a
107  *       zero UDP checksum for either IPv4 or IPv6, the networking stack
108  *       may perform further validation in this case.
109  *     GRE: only if the checksum is present in the header.
110  *     SCTP: indicates the CRC in SCTP header has been validated.
111  *
112  *   skb->csum_level indicates the number of consecutive checksums found in
113  *   the packet minus one that have been verified as CHECKSUM_UNNECESSARY.
114  *   For instance if a device receives an IPv6->UDP->GRE->IPv4->TCP packet
115  *   and a device is able to verify the checksums for UDP (possibly zero),
116  *   GRE (checksum flag is set), and TCP-- skb->csum_level would be set to
117  *   two. If the device were only able to verify the UDP checksum and not
118  *   GRE, either because it doesn't support GRE checksum of because GRE
119  *   checksum is bad, skb->csum_level would be set to zero (TCP checksum is
120  *   not considered in this case).
121  *
122  * CHECKSUM_COMPLETE:
123  *
124  *   This is the most generic way. The device supplied checksum of the _whole_
125  *   packet as seen by netif_rx() and fills out in skb->csum. Meaning, the
126  *   hardware doesn't need to parse L3/L4 headers to implement this.
127  *
128  *   Note: Even if device supports only some protocols, but is able to produce
129  *   skb->csum, it MUST use CHECKSUM_COMPLETE, not CHECKSUM_UNNECESSARY.
130  *
131  * CHECKSUM_PARTIAL:
132  *
133  *   A checksum is set up to be offloaded to a device as described in the
134  *   output description for CHECKSUM_PARTIAL. This may occur on a packet
135  *   received directly from another Linux OS, e.g., a virtualized Linux kernel
136  *   on the same host, or it may be set in the input path in GRO or remote
137  *   checksum offload. For the purposes of checksum verification, the checksum
138  *   referred to by skb->csum_start + skb->csum_offset and any preceding
139  *   checksums in the packet are considered verified. Any checksums in the
140  *   packet that are after the checksum being offloaded are not considered to
141  *   be verified.
142  *
143  * C. Checksumming on transmit for non-GSO. The stack requests checksum offload
144  *    in the skb->ip_summed for a packet. Values are:
145  *
146  * CHECKSUM_PARTIAL:
147  *
148  *   The driver is required to checksum the packet as seen by hard_start_xmit()
149  *   from skb->csum_start up to the end, and to record/write the checksum at
150  *   offset skb->csum_start + skb->csum_offset. A driver may verify that the
151  *   csum_start and csum_offset values are valid values given the length and
152  *   offset of the packet, however they should not attempt to validate that the
153  *   checksum refers to a legitimate transport layer checksum-- it is the
154  *   purview of the stack to validate that csum_start and csum_offset are set
155  *   correctly.
156  *
157  *   When the stack requests checksum offload for a packet, the driver MUST
158  *   ensure that the checksum is set correctly. A driver can either offload the
159  *   checksum calculation to the device, or call skb_checksum_help (in the case
160  *   that the device does not support offload for a particular checksum).
161  *
162  *   NETIF_F_IP_CSUM and NETIF_F_IPV6_CSUM are being deprecated in favor of
163  *   NETIF_F_HW_CSUM. New devices should use NETIF_F_HW_CSUM to indicate
164  *   checksum offload capability. If a  device has limited checksum capabilities
165  *   (for instance can only perform NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM as
166  *   described above) a helper function can be called to resolve
167  *   CHECKSUM_PARTIAL. The helper functions are skb_csum_off_chk*. The helper
168  *   function takes a spec argument that describes the protocol layer that is
169  *   supported for checksum offload and can be called for each packet. If a
170  *   packet does not match the specification for offload, skb_checksum_help
171  *   is called to resolve the checksum.
172  *
173  * CHECKSUM_NONE:
174  *
175  *   The skb was already checksummed by the protocol, or a checksum is not
176  *   required.
177  *
178  * CHECKSUM_UNNECESSARY:
179  *
180  *   This has the same meaning on as CHECKSUM_NONE for checksum offload on
181  *   output.
182  *
183  * CHECKSUM_COMPLETE:
184  *   Not used in checksum output. If a driver observes a packet with this value
185  *   set in skbuff, if should treat as CHECKSUM_NONE being set.
186  *
187  * D. Non-IP checksum (CRC) offloads
188  *
189  *   NETIF_F_SCTP_CRC - This feature indicates that a device is capable of
190  *     offloading the SCTP CRC in a packet. To perform this offload the stack
191  *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
192  *     accordingly. Note the there is no indication in the skbuff that the
193  *     CHECKSUM_PARTIAL refers to an SCTP checksum, a driver that supports
194  *     both IP checksum offload and SCTP CRC offload must verify which offload
195  *     is configured for a packet presumably by inspecting packet headers.
196  *
197  *   NETIF_F_FCOE_CRC - This feature indicates that a device is capable of
198  *     offloading the FCOE CRC in a packet. To perform this offload the stack
199  *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
200  *     accordingly. Note the there is no indication in the skbuff that the
201  *     CHECKSUM_PARTIAL refers to an FCOE checksum, a driver that supports
202  *     both IP checksum offload and FCOE CRC offload must verify which offload
203  *     is configured for a packet presumably by inspecting packet headers.
204  *
205  * E. Checksumming on output with GSO.
206  *
207  * In the case of a GSO packet (skb_is_gso(skb) is true), checksum offload
208  * is implied by the SKB_GSO_* flags in gso_type. Most obviously, if the
209  * gso_type is SKB_GSO_TCPV4 or SKB_GSO_TCPV6, TCP checksum offload as
210  * part of the GSO operation is implied. If a checksum is being offloaded
211  * with GSO then ip_summed is CHECKSUM_PARTIAL, csum_start and csum_offset
212  * are set to refer to the outermost checksum being offload (two offloaded
213  * checksums are possible with UDP encapsulation).
214  */
215 
216 /* Don't change this without changing skb_csum_unnecessary! */
217 #define CHECKSUM_NONE           0
218 #define CHECKSUM_UNNECESSARY    1
219 #define CHECKSUM_COMPLETE       2
220 #define CHECKSUM_PARTIAL        3
221 
222 /* Maximum value in skb->csum_level */
223 #define SKB_MAX_CSUM_LEVEL      3
224 
225 #define SKB_DATA_ALIGN(X)       ALIGN(X, SMP_CACHE_BYTES)
226 #define SKB_WITH_OVERHEAD(X)    \
227         ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
228 #define SKB_MAX_ORDER(X, ORDER) \
229         SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
230 #define SKB_MAX_HEAD(X)         (SKB_MAX_ORDER((X), 0))
231 #define SKB_MAX_ALLOC           (SKB_MAX_ORDER(0, 2))
232 
233 /* return minimum truesize of one skb containing X bytes of data */
234 #define SKB_TRUESIZE(X) ((X) +                                          \
235                          SKB_DATA_ALIGN(sizeof(struct sk_buff)) +       \
236                          SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
237 
238 struct net_device;
239 struct scatterlist;
240 struct pipe_inode_info;
241 struct iov_iter;
242 struct napi_struct;
243 
244 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
245 struct nf_conntrack {
246         atomic_t use;
247 };
248 #endif
249 
250 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
251 struct nf_bridge_info {
252         atomic_t                use;
253         enum {
254                 BRNF_PROTO_UNCHANGED,
255                 BRNF_PROTO_8021Q,
256                 BRNF_PROTO_PPPOE
257         } orig_proto:8;
258         u8                      pkt_otherhost:1;
259         u8                      in_prerouting:1;
260         u8                      bridged_dnat:1;
261         __u16                   frag_max_size;
262         struct net_device       *physindev;
263 
264         /* always valid & non-NULL from FORWARD on, for physdev match */
265         struct net_device       *physoutdev;
266         union {
267                 /* prerouting: detect dnat in orig/reply direction */
268                 __be32          ipv4_daddr;
269                 struct in6_addr ipv6_daddr;
270 
271                 /* after prerouting + nat detected: store original source
272                  * mac since neigh resolution overwrites it, only used while
273                  * skb is out in neigh layer.
274                  */
275                 char neigh_header[8];
276         };
277 };
278 #endif
279 
280 struct sk_buff_head {
281         /* These two members must be first. */
282         struct sk_buff  *next;
283         struct sk_buff  *prev;
284 
285         __u32           qlen;
286         spinlock_t      lock;
287 };
288 
289 struct sk_buff;
290 
291 /* To allow 64K frame to be packed as single skb without frag_list we
292  * require 64K/PAGE_SIZE pages plus 1 additional page to allow for
293  * buffers which do not start on a page boundary.
294  *
295  * Since GRO uses frags we allocate at least 16 regardless of page
296  * size.
297  */
298 #if (65536/PAGE_SIZE + 1) < 16
299 #define MAX_SKB_FRAGS 16UL
300 #else
301 #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 1)
302 #endif
303 extern int sysctl_max_skb_frags;
304 
305 /* Set skb_shinfo(skb)->gso_size to this in case you want skb_segment to
306  * segment using its current segmentation instead.
307  */
308 #define GSO_BY_FRAGS    0xFFFF
309 
310 typedef struct skb_frag_struct skb_frag_t;
311 
312 struct skb_frag_struct {
313         struct {
314                 struct page *p;
315         } page;
316 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
317         __u32 page_offset;
318         __u32 size;
319 #else
320         __u16 page_offset;
321         __u16 size;
322 #endif
323 };
324 
325 static inline unsigned int skb_frag_size(const skb_frag_t *frag)
326 {
327         return frag->size;
328 }
329 
330 static inline void skb_frag_size_set(skb_frag_t *frag, unsigned int size)
331 {
332         frag->size = size;
333 }
334 
335 static inline void skb_frag_size_add(skb_frag_t *frag, int delta)
336 {
337         frag->size += delta;
338 }
339 
340 static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
341 {
342         frag->size -= delta;
343 }
344 
345 #define HAVE_HW_TIME_STAMP
346 
347 /**
348  * struct skb_shared_hwtstamps - hardware time stamps
349  * @hwtstamp:   hardware time stamp transformed into duration
350  *              since arbitrary point in time
351  *
352  * Software time stamps generated by ktime_get_real() are stored in
353  * skb->tstamp.
354  *
355  * hwtstamps can only be compared against other hwtstamps from
356  * the same device.
357  *
358  * This structure is attached to packets as part of the
359  * &skb_shared_info. Use skb_hwtstamps() to get a pointer.
360  */
361 struct skb_shared_hwtstamps {
362         ktime_t hwtstamp;
363 };
364 
365 /* Definitions for tx_flags in struct skb_shared_info */
366 enum {
367         /* generate hardware time stamp */
368         SKBTX_HW_TSTAMP = 1 << 0,
369 
370         /* generate software time stamp when queueing packet to NIC */
371         SKBTX_SW_TSTAMP = 1 << 1,
372 
373         /* device driver is going to provide hardware time stamp */
374         SKBTX_IN_PROGRESS = 1 << 2,
375 
376         /* device driver supports TX zero-copy buffers */
377         SKBTX_DEV_ZEROCOPY = 1 << 3,
378 
379         /* generate wifi status information (where possible) */
380         SKBTX_WIFI_STATUS = 1 << 4,
381 
382         /* This indicates at least one fragment might be overwritten
383          * (as in vmsplice(), sendfile() ...)
384          * If we need to compute a TX checksum, we'll need to copy
385          * all frags to avoid possible bad checksum
386          */
387         SKBTX_SHARED_FRAG = 1 << 5,
388 
389         /* generate software time stamp when entering packet scheduling */
390         SKBTX_SCHED_TSTAMP = 1 << 6,
391 };
392 
393 #define SKBTX_ANY_SW_TSTAMP     (SKBTX_SW_TSTAMP    | \
394                                  SKBTX_SCHED_TSTAMP)
395 #define SKBTX_ANY_TSTAMP        (SKBTX_HW_TSTAMP | SKBTX_ANY_SW_TSTAMP)
396 
397 /*
398  * The callback notifies userspace to release buffers when skb DMA is done in
399  * lower device, the skb last reference should be 0 when calling this.
400  * The zerocopy_success argument is true if zero copy transmit occurred,
401  * false on data copy or out of memory error caused by data copy attempt.
402  * The ctx field is used to track device context.
403  * The desc field is used to track userspace buffer index.
404  */
405 struct ubuf_info {
406         void (*callback)(struct ubuf_info *, bool zerocopy_success);
407         void *ctx;
408         unsigned long desc;
409 };
410 
411 /* This data is invariant across clones and lives at
412  * the end of the header data, ie. at skb->end.
413  */
414 struct skb_shared_info {
415         unsigned char   nr_frags;
416         __u8            tx_flags;
417         unsigned short  gso_size;
418         /* Warning: this field is not always filled in (UFO)! */
419         unsigned short  gso_segs;
420         unsigned short  gso_type;
421         struct sk_buff  *frag_list;
422         struct skb_shared_hwtstamps hwtstamps;
423         u32             tskey;
424         __be32          ip6_frag_id;
425 
426         /*
427          * Warning : all fields before dataref are cleared in __alloc_skb()
428          */
429         atomic_t        dataref;
430 
431         /* Intermediate layers must ensure that destructor_arg
432          * remains valid until skb destructor */
433         void *          destructor_arg;
434 
435         /* must be last field, see pskb_expand_head() */
436         skb_frag_t      frags[MAX_SKB_FRAGS];
437 };
438 
439 /* We divide dataref into two halves.  The higher 16 bits hold references
440  * to the payload part of skb->data.  The lower 16 bits hold references to
441  * the entire skb->data.  A clone of a headerless skb holds the length of
442  * the header in skb->hdr_len.
443  *
444  * All users must obey the rule that the skb->data reference count must be
445  * greater than or equal to the payload reference count.
446  *
447  * Holding a reference to the payload part means that the user does not
448  * care about modifications to the header part of skb->data.
449  */
450 #define SKB_DATAREF_SHIFT 16
451 #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
452 
453 
454 enum {
455         SKB_FCLONE_UNAVAILABLE, /* skb has no fclone (from head_cache) */
456         SKB_FCLONE_ORIG,        /* orig skb (from fclone_cache) */
457         SKB_FCLONE_CLONE,       /* companion fclone skb (from fclone_cache) */
458 };
459 
460 enum {
461         SKB_GSO_TCPV4 = 1 << 0,
462         SKB_GSO_UDP = 1 << 1,
463 
464         /* This indicates the skb is from an untrusted source. */
465         SKB_GSO_DODGY = 1 << 2,
466 
467         /* This indicates the tcp segment has CWR set. */
468         SKB_GSO_TCP_ECN = 1 << 3,
469 
470         SKB_GSO_TCP_FIXEDID = 1 << 4,
471 
472         SKB_GSO_TCPV6 = 1 << 5,
473 
474         SKB_GSO_FCOE = 1 << 6,
475 
476         SKB_GSO_GRE = 1 << 7,
477 
478         SKB_GSO_GRE_CSUM = 1 << 8,
479 
480         SKB_GSO_IPXIP4 = 1 << 9,
481 
482         SKB_GSO_IPXIP6 = 1 << 10,
483 
484         SKB_GSO_UDP_TUNNEL = 1 << 11,
485 
486         SKB_GSO_UDP_TUNNEL_CSUM = 1 << 12,
487 
488         SKB_GSO_PARTIAL = 1 << 13,
489 
490         SKB_GSO_TUNNEL_REMCSUM = 1 << 14,
491 
492         SKB_GSO_SCTP = 1 << 15,
493 };
494 
495 #if BITS_PER_LONG > 32
496 #define NET_SKBUFF_DATA_USES_OFFSET 1
497 #endif
498 
499 #ifdef NET_SKBUFF_DATA_USES_OFFSET
500 typedef unsigned int sk_buff_data_t;
501 #else
502 typedef unsigned char *sk_buff_data_t;
503 #endif
504 
505 /**
506  * struct skb_mstamp - multi resolution time stamps
507  * @stamp_us: timestamp in us resolution
508  * @stamp_jiffies: timestamp in jiffies
509  */
510 struct skb_mstamp {
511         union {
512                 u64             v64;
513                 struct {
514                         u32     stamp_us;
515                         u32     stamp_jiffies;
516                 };
517         };
518 };
519 
520 /**
521  * skb_mstamp_get - get current timestamp
522  * @cl: place to store timestamps
523  */
524 static inline void skb_mstamp_get(struct skb_mstamp *cl)
525 {
526         u64 val = local_clock();
527 
528         do_div(val, NSEC_PER_USEC);
529         cl->stamp_us = (u32)val;
530         cl->stamp_jiffies = (u32)jiffies;
531 }
532 
533 /**
534  * skb_mstamp_delta - compute the difference in usec between two skb_mstamp
535  * @t1: pointer to newest sample
536  * @t0: pointer to oldest sample
537  */
538 static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
539                                       const struct skb_mstamp *t0)
540 {
541         s32 delta_us = t1->stamp_us - t0->stamp_us;
542         u32 delta_jiffies = t1->stamp_jiffies - t0->stamp_jiffies;
543 
544         /* If delta_us is negative, this might be because interval is too big,
545          * or local_clock() drift is too big : fallback using jiffies.
546          */
547         if (delta_us <= 0 ||
548             delta_jiffies >= (INT_MAX / (USEC_PER_SEC / HZ)))
549 
550                 delta_us = jiffies_to_usecs(delta_jiffies);
551 
552         return delta_us;
553 }
554 
555 static inline bool skb_mstamp_after(const struct skb_mstamp *t1,
556                                     const struct skb_mstamp *t0)
557 {
558         s32 diff = t1->stamp_jiffies - t0->stamp_jiffies;
559 
560         if (!diff)
561                 diff = t1->stamp_us - t0->stamp_us;
562         return diff > 0;
563 }
564 
565 /** 
566  *      struct sk_buff - socket buffer
567  *      @next: Next buffer in list
568  *      @prev: Previous buffer in list
569  *      @tstamp: Time we arrived/left
570  *      @rbnode: RB tree node, alternative to next/prev for netem/tcp
571  *      @sk: Socket we are owned by
572  *      @dev: Device we arrived on/are leaving by
573  *      @cb: Control buffer. Free for use by every layer. Put private vars here
574  *      @_skb_refdst: destination entry (with norefcount bit)
575  *      @sp: the security path, used for xfrm
576  *      @len: Length of actual data
577  *      @data_len: Data length
578  *      @mac_len: Length of link layer header
579  *      @hdr_len: writable header length of cloned skb
580  *      @csum: Checksum (must include start/offset pair)
581  *      @csum_start: Offset from skb->head where checksumming should start
582  *      @csum_offset: Offset from csum_start where checksum should be stored
583  *      @priority: Packet queueing priority
584  *      @ignore_df: allow local fragmentation
585  *      @cloned: Head may be cloned (check refcnt to be sure)
586  *      @ip_summed: Driver fed us an IP checksum
587  *      @nohdr: Payload reference only, must not modify header
588  *      @nfctinfo: Relationship of this skb to the connection
589  *      @pkt_type: Packet class
590  *      @fclone: skbuff clone status
591  *      @ipvs_property: skbuff is owned by ipvs
592  *      @peeked: this packet has been seen already, so stats have been
593  *              done for it, don't do them again
594  *      @nf_trace: netfilter packet trace flag
595  *      @protocol: Packet protocol from driver
596  *      @destructor: Destruct function
597  *      @nfct: Associated connection, if any
598  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
599  *      @skb_iif: ifindex of device we arrived on
600  *      @tc_index: Traffic control index
601  *      @tc_verd: traffic control verdict
602  *      @hash: the packet hash
603  *      @queue_mapping: Queue mapping for multiqueue devices
604  *      @xmit_more: More SKBs are pending for this queue
605  *      @ndisc_nodetype: router type (from link layer)
606  *      @ooo_okay: allow the mapping of a socket to a queue to be changed
607  *      @l4_hash: indicate hash is a canonical 4-tuple hash over transport
608  *              ports.
609  *      @sw_hash: indicates hash was computed in software stack
610  *      @wifi_acked_valid: wifi_acked was set
611  *      @wifi_acked: whether frame was acked on wifi or not
612  *      @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
613   *     @napi_id: id of the NAPI struct this skb came from
614  *      @secmark: security marking
615  *      @offload_fwd_mark: fwding offload mark
616  *      @mark: Generic packet mark
617  *      @vlan_proto: vlan encapsulation protocol
618  *      @vlan_tci: vlan tag control information
619  *      @inner_protocol: Protocol (encapsulation)
620  *      @inner_transport_header: Inner transport layer header (encapsulation)
621  *      @inner_network_header: Network layer header (encapsulation)
622  *      @inner_mac_header: Link layer header (encapsulation)
623  *      @transport_header: Transport layer header
624  *      @network_header: Network layer header
625  *      @mac_header: Link layer header
626  *      @tail: Tail pointer
627  *      @end: End pointer
628  *      @head: Head of buffer
629  *      @data: Data head pointer
630  *      @truesize: Buffer size
631  *      @users: User count - see {datagram,tcp}.c
632  */
633 
634 struct sk_buff {
635         union {
636                 struct {
637                         /* These two members must be first. */
638                         struct sk_buff          *next;
639                         struct sk_buff          *prev;
640 
641                         union {
642                                 ktime_t         tstamp;
643                                 struct skb_mstamp skb_mstamp;
644                         };
645                 };
646                 struct rb_node  rbnode; /* used in netem & tcp stack */
647         };
648         struct sock             *sk;
649         struct net_device       *dev;
650 
651         /*
652          * This is the control buffer. It is free to use for every
653          * layer. Please put your private variables there. If you
654          * want to keep them across layers you have to do a skb_clone()
655          * first. This is owned by whoever has the skb queued ATM.
656          */
657         char                    cb[48] __aligned(8);
658 
659         unsigned long           _skb_refdst;
660         void                    (*destructor)(struct sk_buff *skb);
661 #ifdef CONFIG_XFRM
662         struct  sec_path        *sp;
663 #endif
664 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
665         struct nf_conntrack     *nfct;
666 #endif
667 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
668         struct nf_bridge_info   *nf_bridge;
669 #endif
670         unsigned int            len,
671                                 data_len;
672         __u16                   mac_len,
673                                 hdr_len;
674 
675         /* Following fields are _not_ copied in __copy_skb_header()
676          * Note that queue_mapping is here mostly to fill a hole.
677          */
678         kmemcheck_bitfield_begin(flags1);
679         __u16                   queue_mapping;
680         __u8                    cloned:1,
681                                 nohdr:1,
682                                 fclone:2,
683                                 peeked:1,
684                                 head_frag:1,
685                                 xmit_more:1;
686         /* one bit hole */
687         kmemcheck_bitfield_end(flags1);
688 
689         /* fields enclosed in headers_start/headers_end are copied
690          * using a single memcpy() in __copy_skb_header()
691          */
692         /* private: */
693         __u32                   headers_start[0];
694         /* public: */
695 
696 /* if you move pkt_type around you also must adapt those constants */
697 #ifdef __BIG_ENDIAN_BITFIELD
698 #define PKT_TYPE_MAX    (7 << 5)
699 #else
700 #define PKT_TYPE_MAX    7
701 #endif
702 #define PKT_TYPE_OFFSET()       offsetof(struct sk_buff, __pkt_type_offset)
703 
704         __u8                    __pkt_type_offset[0];
705         __u8                    pkt_type:3;
706         __u8                    pfmemalloc:1;
707         __u8                    ignore_df:1;
708         __u8                    nfctinfo:3;
709 
710         __u8                    nf_trace:1;
711         __u8                    ip_summed:2;
712         __u8                    ooo_okay:1;
713         __u8                    l4_hash:1;
714         __u8                    sw_hash:1;
715         __u8                    wifi_acked_valid:1;
716         __u8                    wifi_acked:1;
717 
718         __u8                    no_fcs:1;
719         /* Indicates the inner headers are valid in the skbuff. */
720         __u8                    encapsulation:1;
721         __u8                    encap_hdr_csum:1;
722         __u8                    csum_valid:1;
723         __u8                    csum_complete_sw:1;
724         __u8                    csum_level:2;
725         __u8                    csum_bad:1;
726 
727 #ifdef CONFIG_IPV6_NDISC_NODETYPE
728         __u8                    ndisc_nodetype:2;
729 #endif
730         __u8                    ipvs_property:1;
731         __u8                    inner_protocol_type:1;
732         __u8                    remcsum_offload:1;
733         /* 3 or 5 bit hole */
734 
735 #ifdef CONFIG_NET_SCHED
736         __u16                   tc_index;       /* traffic control index */
737 #ifdef CONFIG_NET_CLS_ACT
738         __u16                   tc_verd;        /* traffic control verdict */
739 #endif
740 #endif
741 
742         union {
743                 __wsum          csum;
744                 struct {
745                         __u16   csum_start;
746                         __u16   csum_offset;
747                 };
748         };
749         __u32                   priority;
750         int                     skb_iif;
751         __u32                   hash;
752         __be16                  vlan_proto;
753         __u16                   vlan_tci;
754 #if defined(CONFIG_NET_RX_BUSY_POLL) || defined(CONFIG_XPS)
755         union {
756                 unsigned int    napi_id;
757                 unsigned int    sender_cpu;
758         };
759 #endif
760         union {
761 #ifdef CONFIG_NETWORK_SECMARK
762                 __u32           secmark;
763 #endif
764 #ifdef CONFIG_NET_SWITCHDEV
765                 __u32           offload_fwd_mark;
766 #endif
767         };
768 
769         union {
770                 __u32           mark;
771                 __u32           reserved_tailroom;
772         };
773 
774         union {
775                 __be16          inner_protocol;
776                 __u8            inner_ipproto;
777         };
778 
779         __u16                   inner_transport_header;
780         __u16                   inner_network_header;
781         __u16                   inner_mac_header;
782 
783         __be16                  protocol;
784         __u16                   transport_header;
785         __u16                   network_header;
786         __u16                   mac_header;
787 
788         /* private: */
789         __u32                   headers_end[0];
790         /* public: */
791 
792         /* These elements must be at the end, see alloc_skb() for details.  */
793         sk_buff_data_t          tail;
794         sk_buff_data_t          end;
795         unsigned char           *head,
796                                 *data;
797         unsigned int            truesize;
798         atomic_t                users;
799 };
800 
801 #ifdef __KERNEL__
802 /*
803  *      Handling routines are only of interest to the kernel
804  */
805 #include <linux/slab.h>
806 
807 
808 #define SKB_ALLOC_FCLONE        0x01
809 #define SKB_ALLOC_RX            0x02
810 #define SKB_ALLOC_NAPI          0x04
811 
812 /* Returns true if the skb was allocated from PFMEMALLOC reserves */
813 static inline bool skb_pfmemalloc(const struct sk_buff *skb)
814 {
815         return unlikely(skb->pfmemalloc);
816 }
817 
818 /*
819  * skb might have a dst pointer attached, refcounted or not.
820  * _skb_refdst low order bit is set if refcount was _not_ taken
821  */
822 #define SKB_DST_NOREF   1UL
823 #define SKB_DST_PTRMASK ~(SKB_DST_NOREF)
824 
825 /**
826  * skb_dst - returns skb dst_entry
827  * @skb: buffer
828  *
829  * Returns skb dst_entry, regardless of reference taken or not.
830  */
831 static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
832 {
833         /* If refdst was not refcounted, check we still are in a 
834          * rcu_read_lock section
835          */
836         WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
837                 !rcu_read_lock_held() &&
838                 !rcu_read_lock_bh_held());
839         return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
840 }
841 
842 /**
843  * skb_dst_set - sets skb dst
844  * @skb: buffer
845  * @dst: dst entry
846  *
847  * Sets skb dst, assuming a reference was taken on dst and should
848  * be released by skb_dst_drop()
849  */
850 static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
851 {
852         skb->_skb_refdst = (unsigned long)dst;
853 }
854 
855 /**
856  * skb_dst_set_noref - sets skb dst, hopefully, without taking reference
857  * @skb: buffer
858  * @dst: dst entry
859  *
860  * Sets skb dst, assuming a reference was not taken on dst.
861  * If dst entry is cached, we do not take reference and dst_release
862  * will be avoided by refdst_drop. If dst entry is not cached, we take
863  * reference, so that last dst_release can destroy the dst immediately.
864  */
865 static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
866 {
867         WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
868         skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
869 }
870 
871 /**
872  * skb_dst_is_noref - Test if skb dst isn't refcounted
873  * @skb: buffer
874  */
875 static inline bool skb_dst_is_noref(const struct sk_buff *skb)
876 {
877         return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
878 }
879 
880 static inline struct rtable *skb_rtable(const struct sk_buff *skb)
881 {
882         return (struct rtable *)skb_dst(skb);
883 }
884 
885 /* For mangling skb->pkt_type from user space side from applications
886  * such as nft, tc, etc, we only allow a conservative subset of
887  * possible pkt_types to be set.
888 */
889 static inline bool skb_pkt_type_ok(u32 ptype)
890 {
891         return ptype <= PACKET_OTHERHOST;
892 }
893 
894 void kfree_skb(struct sk_buff *skb);
895 void kfree_skb_list(struct sk_buff *segs);
896 void skb_tx_error(struct sk_buff *skb);
897 void consume_skb(struct sk_buff *skb);
898 void  __kfree_skb(struct sk_buff *skb);
899 extern struct kmem_cache *skbuff_head_cache;
900 
901 void kfree_skb_partial(struct sk_buff *skb, bool head_stolen);
902 bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
903                       bool *fragstolen, int *delta_truesize);
904 
905 struct sk_buff *__alloc_skb(unsigned int size, gfp_t priority, int flags,
906                             int node);
907 struct sk_buff *__build_skb(void *data, unsigned int frag_size);
908 struct sk_buff *build_skb(void *data, unsigned int frag_size);
909 static inline struct sk_buff *alloc_skb(unsigned int size,
910                                         gfp_t priority)
911 {
912         return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
913 }
914 
915 struct sk_buff *alloc_skb_with_frags(unsigned long header_len,
916                                      unsigned long data_len,
917                                      int max_page_order,
918                                      int *errcode,
919                                      gfp_t gfp_mask);
920 
921 /* Layout of fast clones : [skb1][skb2][fclone_ref] */
922 struct sk_buff_fclones {
923         struct sk_buff  skb1;
924 
925         struct sk_buff  skb2;
926 
927         atomic_t        fclone_ref;
928 };
929 
930 /**
931  *      skb_fclone_busy - check if fclone is busy
932  *      @skb: buffer
933  *
934  * Returns true if skb is a fast clone, and its clone is not freed.
935  * Some drivers call skb_orphan() in their ndo_start_xmit(),
936  * so we also check that this didnt happen.
937  */
938 static inline bool skb_fclone_busy(const struct sock *sk,
939                                    const struct sk_buff *skb)
940 {
941         const struct sk_buff_fclones *fclones;
942 
943         fclones = container_of(skb, struct sk_buff_fclones, skb1);
944 
945         return skb->fclone == SKB_FCLONE_ORIG &&
946                atomic_read(&fclones->fclone_ref) > 1 &&
947                fclones->skb2.sk == sk;
948 }
949 
950 static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
951                                                gfp_t priority)
952 {
953         return __alloc_skb(size, priority, SKB_ALLOC_FCLONE, NUMA_NO_NODE);
954 }
955 
956 struct sk_buff *__alloc_skb_head(gfp_t priority, int node);
957 static inline struct sk_buff *alloc_skb_head(gfp_t priority)
958 {
959         return __alloc_skb_head(priority, -1);
960 }
961 
962 struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
963 int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
964 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
965 struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t priority);
966 struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
967                                    gfp_t gfp_mask, bool fclone);
968 static inline struct sk_buff *__pskb_copy(struct sk_buff *skb, int headroom,
969                                           gfp_t gfp_mask)
970 {
971         return __pskb_copy_fclone(skb, headroom, gfp_mask, false);
972 }
973 
974 int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask);
975 struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
976                                      unsigned int headroom);
977 struct sk_buff *skb_copy_expand(const struct sk_buff *skb, int newheadroom,
978                                 int newtailroom, gfp_t priority);
979 int skb_to_sgvec_nomark(struct sk_buff *skb, struct scatterlist *sg,
980                         int offset, int len);
981 int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset,
982                  int len);
983 int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer);
984 int skb_pad(struct sk_buff *skb, int pad);
985 #define dev_kfree_skb(a)        consume_skb(a)
986 
987 int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
988                             int getfrag(void *from, char *to, int offset,
989                                         int len, int odd, struct sk_buff *skb),
990                             void *from, int length);
991 
992 int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
993                          int offset, size_t size);
994 
995 struct skb_seq_state {
996         __u32           lower_offset;
997         __u32           upper_offset;
998         __u32           frag_idx;
999         __u32           stepped_offset;
1000         struct sk_buff  *root_skb;
1001         struct sk_buff  *cur_skb;
1002         __u8            *frag_data;
1003 };
1004 
1005 void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
1006                           unsigned int to, struct skb_seq_state *st);
1007 unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
1008                           struct skb_seq_state *st);
1009 void skb_abort_seq_read(struct skb_seq_state *st);
1010 
1011 unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
1012                            unsigned int to, struct ts_config *config);
1013 
1014 /*
1015  * Packet hash types specify the type of hash in skb_set_hash.
1016  *
1017  * Hash types refer to the protocol layer addresses which are used to
1018  * construct a packet's hash. The hashes are used to differentiate or identify
1019  * flows of the protocol layer for the hash type. Hash types are either
1020  * layer-2 (L2), layer-3 (L3), or layer-4 (L4).
1021  *
1022  * Properties of hashes:
1023  *
1024  * 1) Two packets in different flows have different hash values
1025  * 2) Two packets in the same flow should have the same hash value
1026  *
1027  * A hash at a higher layer is considered to be more specific. A driver should
1028  * set the most specific hash possible.
1029  *
1030  * A driver cannot indicate a more specific hash than the layer at which a hash
1031  * was computed. For instance an L3 hash cannot be set as an L4 hash.
1032  *
1033  * A driver may indicate a hash level which is less specific than the
1034  * actual layer the hash was computed on. For instance, a hash computed
1035  * at L4 may be considered an L3 hash. This should only be done if the
1036  * driver can't unambiguously determine that the HW computed the hash at
1037  * the higher layer. Note that the "should" in the second property above
1038  * permits this.
1039  */
1040 enum pkt_hash_types {
1041         PKT_HASH_TYPE_NONE,     /* Undefined type */
1042         PKT_HASH_TYPE_L2,       /* Input: src_MAC, dest_MAC */
1043         PKT_HASH_TYPE_L3,       /* Input: src_IP, dst_IP */
1044         PKT_HASH_TYPE_L4,       /* Input: src_IP, dst_IP, src_port, dst_port */
1045 };
1046 
1047 static inline void skb_clear_hash(struct sk_buff *skb)
1048 {
1049         skb->hash = 0;
1050         skb->sw_hash = 0;
1051         skb->l4_hash = 0;
1052 }
1053 
1054 static inline void skb_clear_hash_if_not_l4(struct sk_buff *skb)
1055 {
1056         if (!skb->l4_hash)
1057                 skb_clear_hash(skb);
1058 }
1059 
1060 static inline void
1061 __skb_set_hash(struct sk_buff *skb, __u32 hash, bool is_sw, bool is_l4)
1062 {
1063         skb->l4_hash = is_l4;
1064         skb->sw_hash = is_sw;
1065         skb->hash = hash;
1066 }
1067 
1068 static inline void
1069 skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
1070 {
1071         /* Used by drivers to set hash from HW */
1072         __skb_set_hash(skb, hash, false, type == PKT_HASH_TYPE_L4);
1073 }
1074 
1075 static inline void
1076 __skb_set_sw_hash(struct sk_buff *skb, __u32 hash, bool is_l4)
1077 {
1078         __skb_set_hash(skb, hash, true, is_l4);
1079 }
1080 
1081 void __skb_get_hash(struct sk_buff *skb);
1082 u32 __skb_get_hash_symmetric(struct sk_buff *skb);
1083 u32 skb_get_poff(const struct sk_buff *skb);
1084 u32 __skb_get_poff(const struct sk_buff *skb, void *data,
1085                    const struct flow_keys *keys, int hlen);
1086 __be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
1087                             void *data, int hlen_proto);
1088 
1089 static inline __be32 skb_flow_get_ports(const struct sk_buff *skb,
1090                                         int thoff, u8 ip_proto)
1091 {
1092         return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);
1093 }
1094 
1095 void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
1096                              const struct flow_dissector_key *key,
1097                              unsigned int key_count);
1098 
1099 bool __skb_flow_dissect(const struct sk_buff *skb,
1100                         struct flow_dissector *flow_dissector,
1101                         void *target_container,
1102                         void *data, __be16 proto, int nhoff, int hlen,
1103                         unsigned int flags);
1104 
1105 static inline bool skb_flow_dissect(const struct sk_buff *skb,
1106                                     struct flow_dissector *flow_dissector,
1107                                     void *target_container, unsigned int flags)
1108 {
1109         return __skb_flow_dissect(skb, flow_dissector, target_container,
1110                                   NULL, 0, 0, 0, flags);
1111 }
1112 
1113 static inline bool skb_flow_dissect_flow_keys(const struct sk_buff *skb,
1114                                               struct flow_keys *flow,
1115                                               unsigned int flags)
1116 {
1117         memset(flow, 0, sizeof(*flow));
1118         return __skb_flow_dissect(skb, &flow_keys_dissector, flow,
1119                                   NULL, 0, 0, 0, flags);
1120 }
1121 
1122 static inline bool skb_flow_dissect_flow_keys_buf(struct flow_keys *flow,
1123                                                   void *data, __be16 proto,
1124                                                   int nhoff, int hlen,
1125                                                   unsigned int flags)
1126 {
1127         memset(flow, 0, sizeof(*flow));
1128         return __skb_flow_dissect(NULL, &flow_keys_buf_dissector, flow,
1129                                   data, proto, nhoff, hlen, flags);
1130 }
1131 
1132 static inline __u32 skb_get_hash(struct sk_buff *skb)
1133 {
1134         if (!skb->l4_hash && !skb->sw_hash)
1135                 __skb_get_hash(skb);
1136 
1137         return skb->hash;
1138 }
1139 
1140 __u32 __skb_get_hash_flowi6(struct sk_buff *skb, const struct flowi6 *fl6);
1141 
1142 static inline __u32 skb_get_hash_flowi6(struct sk_buff *skb, const struct flowi6 *fl6)
1143 {
1144         if (!skb->l4_hash && !skb->sw_hash) {
1145                 struct flow_keys keys;
1146                 __u32 hash = __get_hash_from_flowi6(fl6, &keys);
1147 
1148                 __skb_set_sw_hash(skb, hash, flow_keys_have_l4(&keys));
1149         }
1150 
1151         return skb->hash;
1152 }
1153 
1154 __u32 __skb_get_hash_flowi4(struct sk_buff *skb, const struct flowi4 *fl);
1155 
1156 static inline __u32 skb_get_hash_flowi4(struct sk_buff *skb, const struct flowi4 *fl4)
1157 {
1158         if (!skb->l4_hash && !skb->sw_hash) {
1159                 struct flow_keys keys;
1160                 __u32 hash = __get_hash_from_flowi4(fl4, &keys);
1161 
1162                 __skb_set_sw_hash(skb, hash, flow_keys_have_l4(&keys));
1163         }
1164 
1165         return skb->hash;
1166 }
1167 
1168 __u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb);
1169 
1170 static inline __u32 skb_get_hash_raw(const struct sk_buff *skb)
1171 {
1172         return skb->hash;
1173 }
1174 
1175 static inline void skb_copy_hash(struct sk_buff *to, const struct sk_buff *from)
1176 {
1177         to->hash = from->hash;
1178         to->sw_hash = from->sw_hash;
1179         to->l4_hash = from->l4_hash;
1180 };
1181 
1182 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1183 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
1184 {
1185         return skb->head + skb->end;
1186 }
1187 
1188 static inline unsigned int skb_end_offset(const struct sk_buff *skb)
1189 {
1190         return skb->end;
1191 }
1192 #else
1193 static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
1194 {
1195         return skb->end;
1196 }
1197 
1198 static inline unsigned int skb_end_offset(const struct sk_buff *skb)
1199 {
1200         return skb->end - skb->head;
1201 }
1202 #endif
1203 
1204 /* Internal */
1205 #define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
1206 
1207 static inline struct skb_shared_hwtstamps *skb_hwtstamps(struct sk_buff *skb)
1208 {
1209         return &skb_shinfo(skb)->hwtstamps;
1210 }
1211 
1212 /**
1213  *      skb_queue_empty - check if a queue is empty
1214  *      @list: queue head
1215  *
1216  *      Returns true if the queue is empty, false otherwise.
1217  */
1218 static inline int skb_queue_empty(const struct sk_buff_head *list)
1219 {
1220         return list->next == (const struct sk_buff *) list;
1221 }
1222 
1223 /**
1224  *      skb_queue_is_last - check if skb is the last entry in the queue
1225  *      @list: queue head
1226  *      @skb: buffer
1227  *
1228  *      Returns true if @skb is the last buffer on the list.
1229  */
1230 static inline bool skb_queue_is_last(const struct sk_buff_head *list,
1231                                      const struct sk_buff *skb)
1232 {
1233         return skb->next == (const struct sk_buff *) list;
1234 }
1235 
1236 /**
1237  *      skb_queue_is_first - check if skb is the first entry in the queue
1238  *      @list: queue head
1239  *      @skb: buffer
1240  *
1241  *      Returns true if @skb is the first buffer on the list.
1242  */
1243 static inline bool skb_queue_is_first(const struct sk_buff_head *list,
1244                                       const struct sk_buff *skb)
1245 {
1246         return skb->prev == (const struct sk_buff *) list;
1247 }
1248 
1249 /**
1250  *      skb_queue_next - return the next packet in the queue
1251  *      @list: queue head
1252  *      @skb: current buffer
1253  *
1254  *      Return the next packet in @list after @skb.  It is only valid to
1255  *      call this if skb_queue_is_last() evaluates to false.
1256  */
1257 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
1258                                              const struct sk_buff *skb)
1259 {
1260         /* This BUG_ON may seem severe, but if we just return then we
1261          * are going to dereference garbage.
1262          */
1263         BUG_ON(skb_queue_is_last(list, skb));
1264         return skb->next;
1265 }
1266 
1267 /**
1268  *      skb_queue_prev - return the prev packet in the queue
1269  *      @list: queue head
1270  *      @skb: current buffer
1271  *
1272  *      Return the prev packet in @list before @skb.  It is only valid to
1273  *      call this if skb_queue_is_first() evaluates to false.
1274  */
1275 static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list,
1276                                              const struct sk_buff *skb)
1277 {
1278         /* This BUG_ON may seem severe, but if we just return then we
1279          * are going to dereference garbage.
1280          */
1281         BUG_ON(skb_queue_is_first(list, skb));
1282         return skb->prev;
1283 }
1284 
1285 /**
1286  *      skb_get - reference buffer
1287  *      @skb: buffer to reference
1288  *
1289  *      Makes another reference to a socket buffer and returns a pointer
1290  *      to the buffer.
1291  */
1292 static inline struct sk_buff *skb_get(struct sk_buff *skb)
1293 {
1294         atomic_inc(&skb->users);
1295         return skb;
1296 }
1297 
1298 /*
1299  * If users == 1, we are the only owner and are can avoid redundant
1300  * atomic change.
1301  */
1302 
1303 /**
1304  *      skb_cloned - is the buffer a clone
1305  *      @skb: buffer to check
1306  *
1307  *      Returns true if the buffer was generated with skb_clone() and is
1308  *      one of multiple shared copies of the buffer. Cloned buffers are
1309  *      shared data so must not be written to under normal circumstances.
1310  */
1311 static inline int skb_cloned(const struct sk_buff *skb)
1312 {
1313         return skb->cloned &&
1314                (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
1315 }
1316 
1317 static inline int skb_unclone(struct sk_buff *skb, gfp_t pri)
1318 {
1319         might_sleep_if(gfpflags_allow_blocking(pri));
1320 
1321         if (skb_cloned(skb))
1322                 return pskb_expand_head(skb, 0, 0, pri);
1323 
1324         return 0;
1325 }
1326 
1327 /**
1328  *      skb_header_cloned - is the header a clone
1329  *      @skb: buffer to check
1330  *
1331  *      Returns true if modifying the header part of the buffer requires
1332  *      the data to be copied.
1333  */
1334 static inline int skb_header_cloned(const struct sk_buff *skb)
1335 {
1336         int dataref;
1337 
1338         if (!skb->cloned)
1339                 return 0;
1340 
1341         dataref = atomic_read(&skb_shinfo(skb)->dataref);
1342         dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
1343         return dataref != 1;
1344 }
1345 
1346 static inline int skb_header_unclone(struct sk_buff *skb, gfp_t pri)
1347 {
1348         might_sleep_if(gfpflags_allow_blocking(pri));
1349 
1350         if (skb_header_cloned(skb))
1351                 return pskb_expand_head(skb, 0, 0, pri);
1352 
1353         return 0;
1354 }
1355 
1356 /**
1357  *      skb_header_release - release reference to header
1358  *      @skb: buffer to operate on
1359  *
1360  *      Drop a reference to the header part of the buffer.  This is done
1361  *      by acquiring a payload reference.  You must not read from the header
1362  *      part of skb->data after this.
1363  *      Note : Check if you can use __skb_header_release() instead.
1364  */
1365 static inline void skb_header_release(struct sk_buff *skb)
1366 {
1367         BUG_ON(skb->nohdr);
1368         skb->nohdr = 1;
1369         atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
1370 }
1371 
1372 /**
1373  *      __skb_header_release - release reference to header
1374  *      @skb: buffer to operate on
1375  *
1376  *      Variant of skb_header_release() assuming skb is private to caller.
1377  *      We can avoid one atomic operation.
1378  */
1379 static inline void __skb_header_release(struct sk_buff *skb)
1380 {
1381         skb->nohdr = 1;
1382         atomic_set(&skb_shinfo(skb)->dataref, 1 + (1 << SKB_DATAREF_SHIFT));
1383 }
1384 
1385 
1386 /**
1387  *      skb_shared - is the buffer shared
1388  *      @skb: buffer to check
1389  *
1390  *      Returns true if more than one person has a reference to this
1391  *      buffer.
1392  */
1393 static inline int skb_shared(const struct sk_buff *skb)
1394 {
1395         return atomic_read(&skb->users) != 1;
1396 }
1397 
1398 /**
1399  *      skb_share_check - check if buffer is shared and if so clone it
1400  *      @skb: buffer to check
1401  *      @pri: priority for memory allocation
1402  *
1403  *      If the buffer is shared the buffer is cloned and the old copy
1404  *      drops a reference. A new clone with a single reference is returned.
1405  *      If the buffer is not shared the original buffer is returned. When
1406  *      being called from interrupt status or with spinlocks held pri must
1407  *      be GFP_ATOMIC.
1408  *
1409  *      NULL is returned on a memory allocation failure.
1410  */
1411 static inline struct sk_buff *skb_share_check(struct sk_buff *skb, gfp_t pri)
1412 {
1413         might_sleep_if(gfpflags_allow_blocking(pri));
1414         if (skb_shared(skb)) {
1415                 struct sk_buff *nskb = skb_clone(skb, pri);
1416 
1417                 if (likely(nskb))
1418                         consume_skb(skb);
1419                 else
1420                         kfree_skb(skb);
1421                 skb = nskb;
1422         }
1423         return skb;
1424 }
1425 
1426 /*
1427  *      Copy shared buffers into a new sk_buff. We effectively do COW on
1428  *      packets to handle cases where we have a local reader and forward
1429  *      and a couple of other messy ones. The normal one is tcpdumping
1430  *      a packet thats being forwarded.
1431  */
1432 
1433 /**
1434  *      skb_unshare - make a copy of a shared buffer
1435  *      @skb: buffer to check
1436  *      @pri: priority for memory allocation
1437  *
1438  *      If the socket buffer is a clone then this function creates a new
1439  *      copy of the data, drops a reference count on the old copy and returns
1440  *      the new copy with the reference count at 1. If the buffer is not a clone
1441  *      the original buffer is returned. When called with a spinlock held or
1442  *      from interrupt state @pri must be %GFP_ATOMIC
1443  *
1444  *      %NULL is returned on a memory allocation failure.
1445  */
1446 static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
1447                                           gfp_t pri)
1448 {
1449         might_sleep_if(gfpflags_allow_blocking(pri));
1450         if (skb_cloned(skb)) {
1451                 struct sk_buff *nskb = skb_copy(skb, pri);
1452 
1453                 /* Free our shared copy */
1454                 if (likely(nskb))
1455                         consume_skb(skb);
1456                 else
1457                         kfree_skb(skb);
1458                 skb = nskb;
1459         }
1460         return skb;
1461 }
1462 
1463 /**
1464  *      skb_peek - peek at the head of an &sk_buff_head
1465  *      @list_: list to peek at
1466  *
1467  *      Peek an &sk_buff. Unlike most other operations you _MUST_
1468  *      be careful with this one. A peek leaves the buffer on the
1469  *      list and someone else may run off with it. You must hold
1470  *      the appropriate locks or have a private queue to do this.
1471  *
1472  *      Returns %NULL for an empty list or a pointer to the head element.
1473  *      The reference count is not incremented and the reference is therefore
1474  *      volatile. Use with caution.
1475  */
1476 static inline struct sk_buff *skb_peek(const struct sk_buff_head *list_)
1477 {
1478         struct sk_buff *skb = list_->next;
1479 
1480         if (skb == (struct sk_buff *)list_)
1481                 skb = NULL;
1482         return skb;
1483 }
1484 
1485 /**
1486  *      skb_peek_next - peek skb following the given one from a queue
1487  *      @skb: skb to start from
1488  *      @list_: list to peek at
1489  *
1490  *      Returns %NULL when the end of the list is met or a pointer to the
1491  *      next element. The reference count is not incremented and the
1492  *      reference is therefore volatile. Use with caution.
1493  */
1494 static inline struct sk_buff *skb_peek_next(struct sk_buff *skb,
1495                 const struct sk_buff_head *list_)
1496 {
1497         struct sk_buff *next = skb->next;
1498 
1499         if (next == (struct sk_buff *)list_)
1500                 next = NULL;
1501         return next;
1502 }
1503 
1504 /**
1505  *      skb_peek_tail - peek at the tail of an &sk_buff_head
1506  *      @list_: list to peek at
1507  *
1508  *      Peek an &sk_buff. Unlike most other operations you _MUST_
1509  *      be careful with this one. A peek leaves the buffer on the
1510  *      list and someone else may run off with it. You must hold
1511  *      the appropriate locks or have a private queue to do this.
1512  *
1513  *      Returns %NULL for an empty list or a pointer to the tail element.
1514  *      The reference count is not incremented and the reference is therefore
1515  *      volatile. Use with caution.
1516  */
1517 static inline struct sk_buff *skb_peek_tail(const struct sk_buff_head *list_)
1518 {
1519         struct sk_buff *skb = list_->prev;
1520 
1521         if (skb == (struct sk_buff *)list_)
1522                 skb = NULL;
1523         return skb;
1524 
1525 }
1526 
1527 /**
1528  *      skb_queue_len   - get queue length
1529  *      @list_: list to measure
1530  *
1531  *      Return the length of an &sk_buff queue.
1532  */
1533 static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
1534 {
1535         return list_->qlen;
1536 }
1537 
1538 /**
1539  *      __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
1540  *      @list: queue to initialize
1541  *
1542  *      This initializes only the list and queue length aspects of
1543  *      an sk_buff_head object.  This allows to initialize the list
1544  *      aspects of an sk_buff_head without reinitializing things like
1545  *      the spinlock.  It can also be used for on-stack sk_buff_head
1546  *      objects where the spinlock is known to not be used.
1547  */
1548 static inline void __skb_queue_head_init(struct sk_buff_head *list)
1549 {
1550         list->prev = list->next = (struct sk_buff *)list;
1551         list->qlen = 0;
1552 }
1553 
1554 /*
1555  * This function creates a split out lock class for each invocation;
1556  * this is needed for now since a whole lot of users of the skb-queue
1557  * infrastructure in drivers have different locking usage (in hardirq)
1558  * than the networking core (in softirq only). In the long run either the
1559  * network layer or drivers should need annotation to consolidate the
1560  * main types of usage into 3 classes.
1561  */
1562 static inline void skb_queue_head_init(struct sk_buff_head *list)
1563 {
1564         spin_lock_init(&list->lock);
1565         __skb_queue_head_init(list);
1566 }
1567 
1568 static inline void skb_queue_head_init_class(struct sk_buff_head *list,
1569                 struct lock_class_key *class)
1570 {
1571         skb_queue_head_init(list);
1572         lockdep_set_class(&list->lock, class);
1573 }
1574 
1575 /*
1576  *      Insert an sk_buff on a list.
1577  *
1578  *      The "__skb_xxxx()" functions are the non-atomic ones that
1579  *      can only be called with interrupts disabled.
1580  */
1581 void skb_insert(struct sk_buff *old, struct sk_buff *newsk,
1582                 struct sk_buff_head *list);
1583 static inline void __skb_insert(struct sk_buff *newsk,
1584                                 struct sk_buff *prev, struct sk_buff *next,
1585                                 struct sk_buff_head *list)
1586 {
1587         newsk->next = next;
1588         newsk->prev = prev;
1589         next->prev  = prev->next = newsk;
1590         list->qlen++;
1591 }
1592 
1593 static inline void __skb_queue_splice(const struct sk_buff_head *list,
1594                                       struct sk_buff *prev,
1595                                       struct sk_buff *next)
1596 {
1597         struct sk_buff *first = list->next;
1598         struct sk_buff *last = list->prev;
1599 
1600         first->prev = prev;
1601         prev->next = first;
1602 
1603         last->next = next;
1604         next->prev = last;
1605 }
1606 
1607 /**
1608  *      skb_queue_splice - join two skb lists, this is designed for stacks
1609  *      @list: the new list to add
1610  *      @head: the place to add it in the first list
1611  */
1612 static inline void skb_queue_splice(const struct sk_buff_head *list,
1613                                     struct sk_buff_head *head)
1614 {
1615         if (!skb_queue_empty(list)) {
1616                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
1617                 head->qlen += list->qlen;
1618         }
1619 }
1620 
1621 /**
1622  *      skb_queue_splice_init - join two skb lists and reinitialise the emptied list
1623  *      @list: the new list to add
1624  *      @head: the place to add it in the first list
1625  *
1626  *      The list at @list is reinitialised
1627  */
1628 static inline void skb_queue_splice_init(struct sk_buff_head *list,
1629                                          struct sk_buff_head *head)
1630 {
1631         if (!skb_queue_empty(list)) {
1632                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
1633                 head->qlen += list->qlen;
1634                 __skb_queue_head_init(list);
1635         }
1636 }
1637 
1638 /**
1639  *      skb_queue_splice_tail - join two skb lists, each list being a queue
1640  *      @list: the new list to add
1641  *      @head: the place to add it in the first list
1642  */
1643 static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
1644                                          struct sk_buff_head *head)
1645 {
1646         if (!skb_queue_empty(list)) {
1647                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
1648                 head->qlen += list->qlen;
1649         }
1650 }
1651 
1652 /**
1653  *      skb_queue_splice_tail_init - join two skb lists and reinitialise the emptied list
1654  *      @list: the new list to add
1655  *      @head: the place to add it in the first list
1656  *
1657  *      Each of the lists is a queue.
1658  *      The list at @list is reinitialised
1659  */
1660 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
1661                                               struct sk_buff_head *head)
1662 {
1663         if (!skb_queue_empty(list)) {
1664                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
1665                 head->qlen += list->qlen;
1666                 __skb_queue_head_init(list);
1667         }
1668 }
1669 
1670 /**
1671  *      __skb_queue_after - queue a buffer at the list head
1672  *      @list: list to use
1673  *      @prev: place after this buffer
1674  *      @newsk: buffer to queue
1675  *
1676  *      Queue a buffer int the middle of a list. This function takes no locks
1677  *      and you must therefore hold required locks before calling it.
1678  *
1679  *      A buffer cannot be placed on two lists at the same time.
1680  */
1681 static inline void __skb_queue_after(struct sk_buff_head *list,
1682                                      struct sk_buff *prev,
1683                                      struct sk_buff *newsk)
1684 {
1685         __skb_insert(newsk, prev, prev->next, list);
1686 }
1687 
1688 void skb_append(struct sk_buff *old, struct sk_buff *newsk,
1689                 struct sk_buff_head *list);
1690 
1691 static inline void __skb_queue_before(struct sk_buff_head *list,
1692                                       struct sk_buff *next,
1693                                       struct sk_buff *newsk)
1694 {
1695         __skb_insert(newsk, next->prev, next, list);
1696 }
1697 
1698 /**
1699  *      __skb_queue_head - queue a buffer at the list head
1700  *      @list: list to use
1701  *      @newsk: buffer to queue
1702  *
1703  *      Queue a buffer at the start of a list. This function takes no locks
1704  *      and you must therefore hold required locks before calling it.
1705  *
1706  *      A buffer cannot be placed on two lists at the same time.
1707  */
1708 void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
1709 static inline void __skb_queue_head(struct sk_buff_head *list,
1710                                     struct sk_buff *newsk)
1711 {
1712         __skb_queue_after(list, (struct sk_buff *)list, newsk);
1713 }
1714 
1715 /**
1716  *      __skb_queue_tail - queue a buffer at the list tail
1717  *      @list: list to use
1718  *      @newsk: buffer to queue
1719  *
1720  *      Queue a buffer at the end of a list. This function takes no locks
1721  *      and you must therefore hold required locks before calling it.
1722  *
1723  *      A buffer cannot be placed on two lists at the same time.
1724  */
1725 void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
1726 static inline void __skb_queue_tail(struct sk_buff_head *list,
1727                                    struct sk_buff *newsk)
1728 {
1729         __skb_queue_before(list, (struct sk_buff *)list, newsk);
1730 }
1731 
1732 /*
1733  * remove sk_buff from list. _Must_ be called atomically, and with
1734  * the list known..
1735  */
1736 void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
1737 static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
1738 {
1739         struct sk_buff *next, *prev;
1740 
1741         list->qlen--;
1742         next       = skb->next;
1743         prev       = skb->prev;
1744         skb->next  = skb->prev = NULL;
1745         next->prev = prev;
1746         prev->next = next;
1747 }
1748 
1749 /**
1750  *      __skb_dequeue - remove from the head of the queue
1751  *      @list: list to dequeue from
1752  *
1753  *      Remove the head of the list. This function does not take any locks
1754  *      so must be used with appropriate locks held only. The head item is
1755  *      returned or %NULL if the list is empty.
1756  */
1757 struct sk_buff *skb_dequeue(struct sk_buff_head *list);
1758 static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
1759 {
1760         struct sk_buff *skb = skb_peek(list);
1761         if (skb)
1762                 __skb_unlink(skb, list);
1763         return skb;
1764 }
1765 
1766 /**
1767  *      __skb_dequeue_tail - remove from the tail of the queue
1768  *      @list: list to dequeue from
1769  *
1770  *      Remove the tail of the list. This function does not take any locks
1771  *      so must be used with appropriate locks held only. The tail item is
1772  *      returned or %NULL if the list is empty.
1773  */
1774 struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
1775 static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
1776 {
1777         struct sk_buff *skb = skb_peek_tail(list);
1778         if (skb)
1779                 __skb_unlink(skb, list);
1780         return skb;
1781 }
1782 
1783 
1784 static inline bool skb_is_nonlinear(const struct sk_buff *skb)
1785 {
1786         return skb->data_len;
1787 }
1788 
1789 static inline unsigned int skb_headlen(const struct sk_buff *skb)
1790 {
1791         return skb->len - skb->data_len;
1792 }
1793 
1794 static inline int skb_pagelen(const struct sk_buff *skb)
1795 {
1796         int i, len = 0;
1797 
1798         for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
1799                 len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
1800         return len + skb_headlen(skb);
1801 }
1802 
1803 /**
1804  * __skb_fill_page_desc - initialise a paged fragment in an skb
1805  * @skb: buffer containing fragment to be initialised
1806  * @i: paged fragment index to initialise
1807  * @page: the page to use for this fragment
1808  * @off: the offset to the data with @page
1809  * @size: the length of the data
1810  *
1811  * Initialises the @i'th fragment of @skb to point to &size bytes at
1812  * offset @off within @page.
1813  *
1814  * Does not take any additional reference on the fragment.
1815  */
1816 static inline void __skb_fill_page_desc(struct sk_buff *skb, int i,
1817                                         struct page *page, int off, int size)
1818 {
1819         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1820 
1821         /*
1822          * Propagate page pfmemalloc to the skb if we can. The problem is
1823          * that not all callers have unique ownership of the page but rely
1824          * on page_is_pfmemalloc doing the right thing(tm).
1825          */
1826         frag->page.p              = page;
1827         frag->page_offset         = off;
1828         skb_frag_size_set(frag, size);
1829 
1830         page = compound_head(page);
1831         if (page_is_pfmemalloc(page))
1832                 skb->pfmemalloc = true;
1833 }
1834 
1835 /**
1836  * skb_fill_page_desc - initialise a paged fragment in an skb
1837  * @skb: buffer containing fragment to be initialised
1838  * @i: paged fragment index to initialise
1839  * @page: the page to use for this fragment
1840  * @off: the offset to the data with @page
1841  * @size: the length of the data
1842  *
1843  * As per __skb_fill_page_desc() -- initialises the @i'th fragment of
1844  * @skb to point to @size bytes at offset @off within @page. In
1845  * addition updates @skb such that @i is the last fragment.
1846  *
1847  * Does not take any additional reference on the fragment.
1848  */
1849 static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
1850                                       struct page *page, int off, int size)
1851 {
1852         __skb_fill_page_desc(skb, i, page, off, size);
1853         skb_shinfo(skb)->nr_frags = i + 1;
1854 }
1855 
1856 void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off,
1857                      int size, unsigned int truesize);
1858 
1859 void skb_coalesce_rx_frag(struct sk_buff *skb, int i, int size,
1860                           unsigned int truesize);
1861 
1862 #define SKB_PAGE_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->nr_frags)
1863 #define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_has_frag_list(skb))
1864 #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
1865 
1866 #ifdef NET_SKBUFF_DATA_USES_OFFSET
1867 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1868 {
1869         return skb->head + skb->tail;
1870 }
1871 
1872 static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1873 {
1874         skb->tail = skb->data - skb->head;
1875 }
1876 
1877 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1878 {
1879         skb_reset_tail_pointer(skb);
1880         skb->tail += offset;
1881 }
1882 
1883 #else /* NET_SKBUFF_DATA_USES_OFFSET */
1884 static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
1885 {
1886         return skb->tail;
1887 }
1888 
1889 static inline void skb_reset_tail_pointer(struct sk_buff *skb)
1890 {
1891         skb->tail = skb->data;
1892 }
1893 
1894 static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
1895 {
1896         skb->tail = skb->data + offset;
1897 }
1898 
1899 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
1900 
1901 /*
1902  *      Add data to an sk_buff
1903  */
1904 unsigned char *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len);
1905 unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
1906 static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
1907 {
1908         unsigned char *tmp = skb_tail_pointer(skb);
1909         SKB_LINEAR_ASSERT(skb);
1910         skb->tail += len;
1911         skb->len  += len;
1912         return tmp;
1913 }
1914 
1915 unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
1916 static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
1917 {
1918         skb->data -= len;
1919         skb->len  += len;
1920         return skb->data;
1921 }
1922 
1923 unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
1924 static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
1925 {
1926         skb->len -= len;
1927         BUG_ON(skb->len < skb->data_len);
1928         return skb->data += len;
1929 }
1930 
1931 static inline unsigned char *skb_pull_inline(struct sk_buff *skb, unsigned int len)
1932 {
1933         return unlikely(len > skb->len) ? NULL : __skb_pull(skb, len);
1934 }
1935 
1936 unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
1937 
1938 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
1939 {
1940         if (len > skb_headlen(skb) &&
1941             !__pskb_pull_tail(skb, len - skb_headlen(skb)))
1942                 return NULL;
1943         skb->len -= len;
1944         return skb->data += len;
1945 }
1946 
1947 static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
1948 {
1949         return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
1950 }
1951 
1952 static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
1953 {
1954         if (likely(len <= skb_headlen(skb)))
1955                 return 1;
1956         if (unlikely(len > skb->len))
1957                 return 0;
1958         return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
1959 }
1960 
1961 /**
1962  *      skb_headroom - bytes at buffer head
1963  *      @skb: buffer to check
1964  *
1965  *      Return the number of bytes of free space at the head of an &sk_buff.
1966  */
1967 static inline unsigned int skb_headroom(const struct sk_buff *skb)
1968 {
1969         return skb->data - skb->head;
1970 }
1971 
1972 /**
1973  *      skb_tailroom - bytes at buffer end
1974  *      @skb: buffer to check
1975  *
1976  *      Return the number of bytes of free space at the tail of an sk_buff
1977  */
1978 static inline int skb_tailroom(const struct sk_buff *skb)
1979 {
1980         return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
1981 }
1982 
1983 /**
1984  *      skb_availroom - bytes at buffer end
1985  *      @skb: buffer to check
1986  *
1987  *      Return the number of bytes of free space at the tail of an sk_buff
1988  *      allocated by sk_stream_alloc()
1989  */
1990 static inline int skb_availroom(const struct sk_buff *skb)
1991 {
1992         if (skb_is_nonlinear(skb))
1993                 return 0;
1994 
1995         return skb->end - skb->tail - skb->reserved_tailroom;
1996 }
1997 
1998 /**
1999  *      skb_reserve - adjust headroom
2000  *      @skb: buffer to alter
2001  *      @len: bytes to move
2002  *
2003  *      Increase the headroom of an empty &sk_buff by reducing the tail
2004  *      room. This is only allowed for an empty buffer.
2005  */
2006 static inline void skb_reserve(struct sk_buff *skb, int len)
2007 {
2008         skb->data += len;
2009         skb->tail += len;
2010 }
2011 
2012 /**
2013  *      skb_tailroom_reserve - adjust reserved_tailroom
2014  *      @skb: buffer to alter
2015  *      @mtu: maximum amount of headlen permitted
2016  *      @needed_tailroom: minimum amount of reserved_tailroom
2017  *
2018  *      Set reserved_tailroom so that headlen can be as large as possible but
2019  *      not larger than mtu and tailroom cannot be smaller than
2020  *      needed_tailroom.
2021  *      The required headroom should already have been reserved before using
2022  *      this function.
2023  */
2024 static inline void skb_tailroom_reserve(struct sk_buff *skb, unsigned int mtu,
2025                                         unsigned int needed_tailroom)
2026 {
2027         SKB_LINEAR_ASSERT(skb);
2028         if (mtu < skb_tailroom(skb) - needed_tailroom)
2029                 /* use at most mtu */
2030                 skb->reserved_tailroom = skb_tailroom(skb) - mtu;
2031         else
2032                 /* use up to all available space */
2033                 skb->reserved_tailroom = needed_tailroom;
2034 }
2035 
2036 #define ENCAP_TYPE_ETHER        0
2037 #define ENCAP_TYPE_IPPROTO      1
2038 
2039 static inline void skb_set_inner_protocol(struct sk_buff *skb,
2040                                           __be16 protocol)
2041 {
2042         skb->inner_protocol = protocol;
2043         skb->inner_protocol_type = ENCAP_TYPE_ETHER;
2044 }
2045 
2046 static inline void skb_set_inner_ipproto(struct sk_buff *skb,
2047                                          __u8 ipproto)
2048 {
2049         skb->inner_ipproto = ipproto;
2050         skb->inner_protocol_type = ENCAP_TYPE_IPPROTO;
2051 }
2052 
2053 static inline void skb_reset_inner_headers(struct sk_buff *skb)
2054 {
2055         skb->inner_mac_header = skb->mac_header;
2056         skb->inner_network_header = skb->network_header;
2057         skb->inner_transport_header = skb->transport_header;
2058 }
2059 
2060 static inline void skb_reset_mac_len(struct sk_buff *skb)
2061 {
2062         skb->mac_len = skb->network_header - skb->mac_header;
2063 }
2064 
2065 static inline unsigned char *skb_inner_transport_header(const struct sk_buff
2066                                                         *skb)
2067 {
2068         return skb->head + skb->inner_transport_header;
2069 }
2070 
2071 static inline int skb_inner_transport_offset(const struct sk_buff *skb)
2072 {
2073         return skb_inner_transport_header(skb) - skb->data;
2074 }
2075 
2076 static inline void skb_reset_inner_transport_header(struct sk_buff *skb)
2077 {
2078         skb->inner_transport_header = skb->data - skb->head;
2079 }
2080 
2081 static inline void skb_set_inner_transport_header(struct sk_buff *skb,
2082                                                    const int offset)
2083 {
2084         skb_reset_inner_transport_header(skb);
2085         skb->inner_transport_header += offset;
2086 }
2087 
2088 static inline unsigned char *skb_inner_network_header(const struct sk_buff *skb)
2089 {
2090         return skb->head + skb->inner_network_header;
2091 }
2092 
2093 static inline void skb_reset_inner_network_header(struct sk_buff *skb)
2094 {
2095         skb->inner_network_header = skb->data - skb->head;
2096 }
2097 
2098 static inline void skb_set_inner_network_header(struct sk_buff *skb,
2099                                                 const int offset)
2100 {
2101         skb_reset_inner_network_header(skb);
2102         skb->inner_network_header += offset;
2103 }
2104 
2105 static inline unsigned char *skb_inner_mac_header(const struct sk_buff *skb)
2106 {
2107         return skb->head + skb->inner_mac_header;
2108 }
2109 
2110 static inline void skb_reset_inner_mac_header(struct sk_buff *skb)
2111 {
2112         skb->inner_mac_header = skb->data - skb->head;
2113 }
2114 
2115 static inline void skb_set_inner_mac_header(struct sk_buff *skb,
2116                                             const int offset)
2117 {
2118         skb_reset_inner_mac_header(skb);
2119         skb->inner_mac_header += offset;
2120 }
2121 static inline bool skb_transport_header_was_set(const struct sk_buff *skb)
2122 {
2123         return skb->transport_header != (typeof(skb->transport_header))~0U;
2124 }
2125 
2126 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
2127 {
2128         return skb->head + skb->transport_header;
2129 }
2130 
2131 static inline void skb_reset_transport_header(struct sk_buff *skb)
2132 {
2133         skb->transport_header = skb->data - skb->head;
2134 }
2135 
2136 static inline void skb_set_transport_header(struct sk_buff *skb,
2137                                             const int offset)
2138 {
2139         skb_reset_transport_header(skb);
2140         skb->transport_header += offset;
2141 }
2142 
2143 static inline unsigned char *skb_network_header(const struct sk_buff *skb)
2144 {
2145         return skb->head + skb->network_header;
2146 }
2147 
2148 static inline void skb_reset_network_header(struct sk_buff *skb)
2149 {
2150         skb->network_header = skb->data - skb->head;
2151 }
2152 
2153 static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
2154 {
2155         skb_reset_network_header(skb);
2156         skb->network_header += offset;
2157 }
2158 
2159 static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
2160 {
2161         return skb->head + skb->mac_header;
2162 }
2163 
2164 static inline int skb_mac_header_was_set(const struct sk_buff *skb)
2165 {
2166         return skb->mac_header != (typeof(skb->mac_header))~0U;
2167 }
2168 
2169 static inline void skb_reset_mac_header(struct sk_buff *skb)
2170 {
2171         skb->mac_header = skb->data - skb->head;
2172 }
2173 
2174 static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
2175 {
2176         skb_reset_mac_header(skb);
2177         skb->mac_header += offset;
2178 }
2179 
2180 static inline void skb_pop_mac_header(struct sk_buff *skb)
2181 {
2182         skb->mac_header = skb->network_header;
2183 }
2184 
2185 static inline void skb_probe_transport_header(struct sk_buff *skb,
2186                                               const int offset_hint)
2187 {
2188         struct flow_keys keys;
2189 
2190         if (skb_transport_header_was_set(skb))
2191                 return;
2192         else if (skb_flow_dissect_flow_keys(skb, &keys, 0))
2193                 skb_set_transport_header(skb, keys.control.thoff);
2194         else
2195                 skb_set_transport_header(skb, offset_hint);
2196 }
2197 
2198 static inline void skb_mac_header_rebuild(struct sk_buff *skb)
2199 {
2200         if (skb_mac_header_was_set(skb)) {
2201                 const unsigned char *old_mac = skb_mac_header(skb);
2202 
2203                 skb_set_mac_header(skb, -skb->mac_len);
2204                 memmove(skb_mac_header(skb), old_mac, skb->mac_len);
2205         }
2206 }
2207 
2208 static inline int skb_checksum_start_offset(const struct sk_buff *skb)
2209 {
2210         return skb->csum_start - skb_headroom(skb);
2211 }
2212 
2213 static inline unsigned char *skb_checksum_start(const struct sk_buff *skb)
2214 {
2215         return skb->head + skb->csum_start;
2216 }
2217 
2218 static inline int skb_transport_offset(const struct sk_buff *skb)
2219 {
2220         return skb_transport_header(skb) - skb->data;
2221 }
2222 
2223 static inline u32 skb_network_header_len(const struct sk_buff *skb)
2224 {
2225         return skb->transport_header - skb->network_header;
2226 }
2227 
2228 static inline u32 skb_inner_network_header_len(const struct sk_buff *skb)
2229 {
2230         return skb->inner_transport_header - skb->inner_network_header;
2231 }
2232 
2233 static inline int skb_network_offset(const struct sk_buff *skb)
2234 {
2235         return skb_network_header(skb) - skb->data;
2236 }
2237 
2238 static inline int skb_inner_network_offset(const struct sk_buff *skb)
2239 {
2240         return skb_inner_network_header(skb) - skb->data;
2241 }
2242 
2243 static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len)
2244 {
2245         return pskb_may_pull(skb, skb_network_offset(skb) + len);
2246 }
2247 
2248 /*
2249  * CPUs often take a performance hit when accessing unaligned memory
2250  * locations. The actual performance hit varies, it can be small if the
2251  * hardware handles it or large if we have to take an exception and fix it
2252  * in software.
2253  *
2254  * Since an ethernet header is 14 bytes network drivers often end up with
2255  * the IP header at an unaligned offset. The IP header can be aligned by
2256  * shifting the start of the packet by 2 bytes. Drivers should do this
2257  * with:
2258  *
2259  * skb_reserve(skb, NET_IP_ALIGN);
2260  *
2261  * The downside to this alignment of the IP header is that the DMA is now
2262  * unaligned. On some architectures the cost of an unaligned DMA is high
2263  * and this cost outweighs the gains made by aligning the IP header.
2264  *
2265  * Since this trade off varies between architectures, we allow NET_IP_ALIGN
2266  * to be overridden.
2267  */
2268 #ifndef NET_IP_ALIGN
2269 #define NET_IP_ALIGN    2
2270 #endif
2271 
2272 /*
2273  * The networking layer reserves some headroom in skb data (via
2274  * dev_alloc_skb). This is used to avoid having to reallocate skb data when
2275  * the header has to grow. In the default case, if the header has to grow
2276  * 32 bytes or less we avoid the reallocation.
2277  *
2278  * Unfortunately this headroom changes the DMA alignment of the resulting
2279  * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
2280  * on some architectures. An architecture can override this value,
2281  * perhaps setting it to a cacheline in size (since that will maintain
2282  * cacheline alignment of the DMA). It must be a power of 2.
2283  *
2284  * Various parts of the networking layer expect at least 32 bytes of
2285  * headroom, you should not reduce this.
2286  *
2287  * Using max(32, L1_CACHE_BYTES) makes sense (especially with RPS)
2288  * to reduce average number of cache lines per packet.
2289  * get_rps_cpus() for example only access one 64 bytes aligned block :
2290  * NET_IP_ALIGN(2) + ethernet_header(14) + IP_header(20/40) + ports(8)
2291  */
2292 #ifndef NET_SKB_PAD
2293 #define NET_SKB_PAD     max(32, L1_CACHE_BYTES)
2294 #endif
2295 
2296 int ___pskb_trim(struct sk_buff *skb, unsigned int len);
2297 
2298 static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
2299 {
2300         if (unlikely(skb_is_nonlinear(skb))) {
2301                 WARN_ON(1);
2302                 return;
2303         }
2304         skb->len = len;
2305         skb_set_tail_pointer(skb, len);
2306 }
2307 
2308 void skb_trim(struct sk_buff *skb, unsigned int len);
2309 
2310 static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
2311 {
2312         if (skb->data_len)
2313                 return ___pskb_trim(skb, len);
2314         __skb_trim(skb, len);
2315         return 0;
2316 }
2317 
2318 static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
2319 {
2320         return (len < skb->len) ? __pskb_trim(skb, len) : 0;
2321 }
2322 
2323 /**
2324  *      pskb_trim_unique - remove end from a paged unique (not cloned) buffer
2325  *      @skb: buffer to alter
2326  *      @len: new length
2327  *
2328  *      This is identical to pskb_trim except that the caller knows that
2329  *      the skb is not cloned so we should never get an error due to out-
2330  *      of-memory.
2331  */
2332 static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
2333 {
2334         int err = pskb_trim(skb, len);
2335         BUG_ON(err);
2336 }
2337 
2338 /**
2339  *      skb_orphan - orphan a buffer
2340  *      @skb: buffer to orphan
2341  *
2342  *      If a buffer currently has an owner then we call the owner's
2343  *      destructor function and make the @skb unowned. The buffer continues
2344  *      to exist but is no longer charged to its former owner.
2345  */
2346 static inline void skb_orphan(struct sk_buff *skb)
2347 {
2348         if (skb->destructor) {
2349                 skb->destructor(skb);
2350                 skb->destructor = NULL;
2351                 skb->sk         = NULL;
2352         } else {
2353                 BUG_ON(skb->sk);
2354         }
2355 }
2356 
2357 /**
2358  *      skb_orphan_frags - orphan the frags contained in a buffer
2359  *      @skb: buffer to orphan frags from
2360  *      @gfp_mask: allocation mask for replacement pages
2361  *
2362  *      For each frag in the SKB which needs a destructor (i.e. has an
2363  *      owner) create a copy of that frag and release the original
2364  *      page by calling the destructor.
2365  */
2366 static inline int skb_orphan_frags(struct sk_buff *skb, gfp_t gfp_mask)
2367 {
2368         if (likely(!(skb_shinfo(skb)->tx_flags & SKBTX_DEV_ZEROCOPY)))
2369                 return 0;
2370         return skb_copy_ubufs(skb, gfp_mask);
2371 }
2372 
2373 /**
2374  *      __skb_queue_purge - empty a list
2375  *      @list: list to empty
2376  *
2377  *      Delete all buffers on an &sk_buff list. Each buffer is removed from
2378  *      the list and one reference dropped. This function does not take the
2379  *      list lock and the caller must hold the relevant locks to use it.
2380  */
2381 void skb_queue_purge(struct sk_buff_head *list);
2382 static inline void __skb_queue_purge(struct sk_buff_head *list)
2383 {
2384         struct sk_buff *skb;
2385         while ((skb = __skb_dequeue(list)) != NULL)
2386                 kfree_skb(skb);
2387 }
2388 
2389 void *netdev_alloc_frag(unsigned int fragsz);
2390 
2391 struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int length,
2392                                    gfp_t gfp_mask);
2393 
2394 /**
2395  *      netdev_alloc_skb - allocate an skbuff for rx on a specific device
2396  *      @dev: network device to receive on
2397  *      @length: length to allocate
2398  *
2399  *      Allocate a new &sk_buff and assign it a usage count of one. The
2400  *      buffer has unspecified headroom built in. Users should allocate
2401  *      the headroom they think they need without accounting for the
2402  *      built in space. The built in space is used for optimisations.
2403  *
2404  *      %NULL is returned if there is no free memory. Although this function
2405  *      allocates memory it can be called from an interrupt.
2406  */
2407 static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
2408                                                unsigned int length)
2409 {
2410         return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
2411 }
2412 
2413 /* legacy helper around __netdev_alloc_skb() */
2414 static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
2415                                               gfp_t gfp_mask)
2416 {
2417         return __netdev_alloc_skb(NULL, length, gfp_mask);
2418 }
2419 
2420 /* legacy helper around netdev_alloc_skb() */
2421 static inline struct sk_buff *dev_alloc_skb(unsigned int length)
2422 {
2423         return netdev_alloc_skb(NULL, length);
2424 }
2425 
2426 
2427 static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
2428                 unsigned int length, gfp_t gfp)
2429 {
2430         struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
2431 
2432         if (NET_IP_ALIGN && skb)
2433                 skb_reserve(skb, NET_IP_ALIGN);
2434         return skb;
2435 }
2436 
2437 static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
2438                 unsigned int length)
2439 {
2440         return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
2441 }
2442 
2443 static inline void skb_free_frag(void *addr)
2444 {
2445         __free_page_frag(addr);
2446 }
2447 
2448 void *napi_alloc_frag(unsigned int fragsz);
2449 struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
2450                                  unsigned int length, gfp_t gfp_mask);
2451 static inline struct sk_buff *napi_alloc_skb(struct napi_struct *napi,
2452                                              unsigned int length)
2453 {
2454         return __napi_alloc_skb(napi, length, GFP_ATOMIC);
2455 }
2456 void napi_consume_skb(struct sk_buff *skb, int budget);
2457 
2458 void __kfree_skb_flush(void);
2459 void __kfree_skb_defer(struct sk_buff *skb);
2460 
2461 /**
2462  * __dev_alloc_pages - allocate page for network Rx
2463  * @gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx
2464  * @order: size of the allocation
2465  *
2466  * Allocate a new page.
2467  *
2468  * %NULL is returned if there is no free memory.
2469 */
2470 static inline struct page *__dev_alloc_pages(gfp_t gfp_mask,
2471                                              unsigned int order)
2472 {
2473         /* This piece of code contains several assumptions.
2474          * 1.  This is for device Rx, therefor a cold page is preferred.
2475          * 2.  The expectation is the user wants a compound page.
2476          * 3.  If requesting a order 0 page it will not be compound
2477          *     due to the check to see if order has a value in prep_new_page
2478          * 4.  __GFP_MEMALLOC is ignored if __GFP_NOMEMALLOC is set due to
2479          *     code in gfp_to_alloc_flags that should be enforcing this.
2480          */
2481         gfp_mask |= __GFP_COLD | __GFP_COMP | __GFP_MEMALLOC;
2482 
2483         return alloc_pages_node(NUMA_NO_NODE, gfp_mask, order);
2484 }
2485 
2486 static inline struct page *dev_alloc_pages(unsigned int order)
2487 {
2488         return __dev_alloc_pages(GFP_ATOMIC | __GFP_NOWARN, order);
2489 }
2490 
2491 /**
2492  * __dev_alloc_page - allocate a page for network Rx
2493  * @gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx
2494  *
2495  * Allocate a new page.
2496  *
2497  * %NULL is returned if there is no free memory.
2498  */
2499 static inline struct page *__dev_alloc_page(gfp_t gfp_mask)
2500 {
2501         return __dev_alloc_pages(gfp_mask, 0);
2502 }
2503 
2504 static inline struct page *dev_alloc_page(void)
2505 {
2506         return dev_alloc_pages(0);
2507 }
2508 
2509 /**
2510  *      skb_propagate_pfmemalloc - Propagate pfmemalloc if skb is allocated after RX page
2511  *      @page: The page that was allocated from skb_alloc_page
2512  *      @skb: The skb that may need pfmemalloc set
2513  */
2514 static inline void skb_propagate_pfmemalloc(struct page *page,
2515                                              struct sk_buff *skb)
2516 {
2517         if (page_is_pfmemalloc(page))
2518                 skb->pfmemalloc = true;
2519 }
2520 
2521 /**
2522  * skb_frag_page - retrieve the page referred to by a paged fragment
2523  * @frag: the paged fragment
2524  *
2525  * Returns the &struct page associated with @frag.
2526  */
2527 static inline struct page *skb_frag_page(const skb_frag_t *frag)
2528 {
2529         return frag->page.p;
2530 }
2531 
2532 /**
2533  * __skb_frag_ref - take an addition reference on a paged fragment.
2534  * @frag: the paged fragment
2535  *
2536  * Takes an additional reference on the paged fragment @frag.
2537  */
2538 static inline void __skb_frag_ref(skb_frag_t *frag)
2539 {
2540         get_page(skb_frag_page(frag));
2541 }
2542 
2543 /**
2544  * skb_frag_ref - take an addition reference on a paged fragment of an skb.
2545  * @skb: the buffer
2546  * @f: the fragment offset.
2547  *
2548  * Takes an additional reference on the @f'th paged fragment of @skb.
2549  */
2550 static inline void skb_frag_ref(struct sk_buff *skb, int f)
2551 {
2552         __skb_frag_ref(&skb_shinfo(skb)->frags[f]);
2553 }
2554 
2555 /**
2556  * __skb_frag_unref - release a reference on a paged fragment.
2557  * @frag: the paged fragment
2558  *
2559  * Releases a reference on the paged fragment @frag.
2560  */
2561 static inline void __skb_frag_unref(skb_frag_t *frag)
2562 {
2563         put_page(skb_frag_page(frag));
2564 }
2565 
2566 /**
2567  * skb_frag_unref - release a reference on a paged fragment of an skb.
2568  * @skb: the buffer
2569  * @f: the fragment offset
2570  *
2571  * Releases a reference on the @f'th paged fragment of @skb.
2572  */
2573 static inline void skb_frag_unref(struct sk_buff *skb, int f)
2574 {
2575         __skb_frag_unref(&skb_shinfo(skb)->frags[f]);
2576 }
2577 
2578 /**
2579  * skb_frag_address - gets the address of the data contained in a paged fragment
2580  * @frag: the paged fragment buffer
2581  *
2582  * Returns the address of the data within @frag. The page must already
2583  * be mapped.
2584  */
2585 static inline void *skb_frag_address(const skb_frag_t *frag)
2586 {
2587         return page_address(skb_frag_page(frag)) + frag->page_offset;
2588 }
2589 
2590 /**
2591  * skb_frag_address_safe - gets the address of the data contained in a paged fragment
2592  * @frag: the paged fragment buffer
2593  *
2594  * Returns the address of the data within @frag. Checks that the page
2595  * is mapped and returns %NULL otherwise.
2596  */
2597 static inline void *skb_frag_address_safe(const skb_frag_t *frag)
2598 {
2599         void *ptr = page_address(skb_frag_page(frag));
2600         if (unlikely(!ptr))
2601                 return NULL;
2602 
2603         return ptr + frag->page_offset;
2604 }
2605 
2606 /**
2607  * __skb_frag_set_page - sets the page contained in a paged fragment
2608  * @frag: the paged fragment
2609  * @page: the page to set
2610  *
2611  * Sets the fragment @frag to contain @page.
2612  */
2613 static inline void __skb_frag_set_page(skb_frag_t *frag, struct page *page)
2614 {
2615         frag->page.p = page;
2616 }
2617 
2618 /**
2619  * skb_frag_set_page - sets the page contained in a paged fragment of an skb
2620  * @skb: the buffer
2621  * @f: the fragment offset
2622  * @page: the page to set
2623  *
2624  * Sets the @f'th fragment of @skb to contain @page.
2625  */
2626 static inline void skb_frag_set_page(struct sk_buff *skb, int f,
2627                                      struct page *page)
2628 {
2629         __skb_frag_set_page(&skb_shinfo(skb)->frags[f], page);
2630 }
2631 
2632 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t prio);
2633 
2634 /**
2635  * skb_frag_dma_map - maps a paged fragment via the DMA API
2636  * @dev: the device to map the fragment to
2637  * @frag: the paged fragment to map
2638  * @offset: the offset within the fragment (starting at the
2639  *          fragment's own offset)
2640  * @size: the number of bytes to map
2641  * @dir: the direction of the mapping (%PCI_DMA_*)
2642  *
2643  * Maps the page associated with @frag to @device.
2644  */
2645 static inline dma_addr_t skb_frag_dma_map(struct device *dev,
2646                                           const skb_frag_t *frag,
2647                                           size_t offset, size_t size,
2648                                           enum dma_data_direction dir)
2649 {
2650         return dma_map_page(dev, skb_frag_page(frag),
2651                             frag->page_offset + offset, size, dir);
2652 }
2653 
2654 static inline struct sk_buff *pskb_copy(struct sk_buff *skb,
2655                                         gfp_t gfp_mask)
2656 {
2657         return __pskb_copy(skb, skb_headroom(skb), gfp_mask);
2658 }
2659 
2660 
2661 static inline struct sk_buff *pskb_copy_for_clone(struct sk_buff *skb,
2662                                                   gfp_t gfp_mask)
2663 {
2664         return __pskb_copy_fclone(skb, skb_headroom(skb), gfp_mask, true);
2665 }
2666 
2667 
2668 /**
2669  *      skb_clone_writable - is the header of a clone writable
2670  *      @skb: buffer to check
2671  *      @len: length up to which to write
2672  *
2673  *      Returns true if modifying the header part of the cloned buffer
2674  *      does not requires the data to be copied.
2675  */
2676 static inline int skb_clone_writable(const struct sk_buff *skb, unsigned int len)
2677 {
2678         return !skb_header_cloned(skb) &&
2679                skb_headroom(skb) + len <= skb->hdr_len;
2680 }
2681 
2682 static inline int skb_try_make_writable(struct sk_buff *skb,
2683                                         unsigned int write_len)
2684 {
2685         return skb_cloned(skb) && !skb_clone_writable(skb, write_len) &&
2686                pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
2687 }
2688 
2689 static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
2690                             int cloned)
2691 {
2692         int delta = 0;
2693 
2694         if (headroom > skb_headroom(skb))
2695                 delta = headroom - skb_headroom(skb);
2696 
2697         if (delta || cloned)
2698                 return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
2699                                         GFP_ATOMIC);
2700         return 0;
2701 }
2702 
2703 /**
2704  *      skb_cow - copy header of skb when it is required
2705  *      @skb: buffer to cow
2706  *      @headroom: needed headroom
2707  *
2708  *      If the skb passed lacks sufficient headroom or its data part
2709  *      is shared, data is reallocated. If reallocation fails, an error
2710  *      is returned and original skb is not changed.
2711  *
2712  *      The result is skb with writable area skb->head...skb->tail
2713  *      and at least @headroom of space at head.
2714  */
2715 static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
2716 {
2717         return __skb_cow(skb, headroom, skb_cloned(skb));
2718 }
2719 
2720 /**
2721  *      skb_cow_head - skb_cow but only making the head writable
2722  *      @skb: buffer to cow
2723  *      @headroom: needed headroom
2724  *
2725  *      This function is identical to skb_cow except that we replace the
2726  *      skb_cloned check by skb_header_cloned.  It should be used when
2727  *      you only need to push on some header and do not need to modify
2728  *      the data.
2729  */
2730 static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
2731 {
2732         return __skb_cow(skb, headroom, skb_header_cloned(skb));
2733 }
2734 
2735 /**
2736  *      skb_padto       - pad an skbuff up to a minimal size
2737  *      @skb: buffer to pad
2738  *      @len: minimal length
2739  *
2740  *      Pads up a buffer to ensure the trailing bytes exist and are
2741  *      blanked. If the buffer already contains sufficient data it
2742  *      is untouched. Otherwise it is extended. Returns zero on
2743  *      success. The skb is freed on error.
2744  */
2745 static inline int skb_padto(struct sk_buff *skb, unsigned int len)
2746 {
2747         unsigned int size = skb->len;
2748         if (likely(size >= len))
2749                 return 0;
2750         return skb_pad(skb, len - size);
2751 }
2752 
2753 /**
2754  *      skb_put_padto - increase size and pad an skbuff up to a minimal size
2755  *      @skb: buffer to pad
2756  *      @len: minimal length
2757  *
2758  *      Pads up a buffer to ensure the trailing bytes exist and are
2759  *      blanked. If the buffer already contains sufficient data it
2760  *      is untouched. Otherwise it is extended. Returns zero on
2761  *      success. The skb is freed on error.
2762  */
2763 static inline int skb_put_padto(struct sk_buff *skb, unsigned int len)
2764 {
2765         unsigned int size = skb->len;
2766 
2767         if (unlikely(size < len)) {
2768                 len -= size;
2769                 if (skb_pad(skb, len))
2770                         return -ENOMEM;
2771                 __skb_put(skb, len);
2772         }
2773         return 0;
2774 }
2775 
2776 static inline int skb_add_data(struct sk_buff *skb,
2777                                struct iov_iter *from, int copy)
2778 {
2779         const int off = skb->len;
2780 
2781         if (skb->ip_summed == CHECKSUM_NONE) {
2782                 __wsum csum = 0;
2783                 if (csum_and_copy_from_iter(skb_put(skb, copy), copy,
2784                                             &csum, from) == copy) {
2785                         skb->csum = csum_block_add(skb->csum, csum, off);
2786                         return 0;
2787                 }
2788         } else if (copy_from_iter(skb_put(skb, copy), copy, from) == copy)
2789                 return 0;
2790 
2791         __skb_trim(skb, off);
2792         return -EFAULT;
2793 }
2794 
2795 static inline bool skb_can_coalesce(struct sk_buff *skb, int i,
2796                                     const struct page *page, int off)
2797 {
2798         if (i) {
2799                 const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
2800 
2801                 return page == skb_frag_page(frag) &&
2802                        off == frag->page_offset + skb_frag_size(frag);
2803         }
2804         return false;
2805 }
2806 
2807 static inline int __skb_linearize(struct sk_buff *skb)
2808 {
2809         return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
2810 }
2811 
2812 /**
2813  *      skb_linearize - convert paged skb to linear one
2814  *      @skb: buffer to linarize
2815  *
2816  *      If there is no free memory -ENOMEM is returned, otherwise zero
2817  *      is returned and the old skb data released.
2818  */
2819 static inline int skb_linearize(struct sk_buff *skb)
2820 {
2821         return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
2822 }
2823 
2824 /**
2825  * skb_has_shared_frag - can any frag be overwritten
2826  * @skb: buffer to test
2827  *
2828  * Return true if the skb has at least one frag that might be modified
2829  * by an external entity (as in vmsplice()/sendfile())
2830  */
2831 static inline bool skb_has_shared_frag(const struct sk_buff *skb)
2832 {
2833         return skb_is_nonlinear(skb) &&
2834                skb_shinfo(skb)->tx_flags & SKBTX_SHARED_FRAG;
2835 }
2836 
2837 /**
2838  *      skb_linearize_cow - make sure skb is linear and writable
2839  *      @skb: buffer to process
2840  *
2841  *      If there is no free memory -ENOMEM is returned, otherwise zero
2842  *      is returned and the old skb data released.
2843  */
2844 static inline int skb_linearize_cow(struct sk_buff *skb)
2845 {
2846         return skb_is_nonlinear(skb) || skb_cloned(skb) ?
2847                __skb_linearize(skb) : 0;
2848 }
2849 
2850 static __always_inline void
2851 __skb_postpull_rcsum(struct sk_buff *skb, const void *start, unsigned int len,
2852                      unsigned int off)
2853 {
2854         if (skb->ip_summed == CHECKSUM_COMPLETE)
2855                 skb->csum = csum_block_sub(skb->csum,
2856                                            csum_partial(start, len, 0), off);
2857         else if (skb->ip_summed == CHECKSUM_PARTIAL &&
2858                  skb_checksum_start_offset(skb) < 0)
2859                 skb->ip_summed = CHECKSUM_NONE;
2860 }
2861 
2862 /**
2863  *      skb_postpull_rcsum - update checksum for received skb after pull
2864  *      @skb: buffer to update
2865  *      @start: start of data before pull
2866  *      @len: length of data pulled
2867  *
2868  *      After doing a pull on a received packet, you need to call this to
2869  *      update the CHECKSUM_COMPLETE checksum, or set ip_summed to
2870  *      CHECKSUM_NONE so that it can be recomputed from scratch.
2871  */
2872 static inline void skb_postpull_rcsum(struct sk_buff *skb,
2873                                       const void *start, unsigned int len)
2874 {
2875         __skb_postpull_rcsum(skb, start, len, 0);
2876 }
2877 
2878 static __always_inline void
2879 __skb_postpush_rcsum(struct sk_buff *skb, const void *start, unsigned int len,
2880                      unsigned int off)
2881 {
2882         if (skb->ip_summed == CHECKSUM_COMPLETE)
2883                 skb->csum = csum_block_add(skb->csum,
2884                                            csum_partial(start, len, 0), off);
2885 }
2886 
2887 /**
2888  *      skb_postpush_rcsum - update checksum for received skb after push
2889  *      @skb: buffer to update
2890  *      @start: start of data after push
2891  *      @len: length of data pushed
2892  *
2893  *      After doing a push on a received packet, you need to call this to
2894  *      update the CHECKSUM_COMPLETE checksum.
2895  */
2896 static inline void skb_postpush_rcsum(struct sk_buff *skb,
2897                                       const void *start, unsigned int len)
2898 {
2899         __skb_postpush_rcsum(skb, start, len, 0);
2900 }
2901 
2902 unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
2903 
2904 /**
2905  *      skb_push_rcsum - push skb and update receive checksum
2906  *      @skb: buffer to update
2907  *      @len: length of data pulled
2908  *
2909  *      This function performs an skb_push on the packet and updates
2910  *      the CHECKSUM_COMPLETE checksum.  It should be used on
2911  *      receive path processing instead of skb_push unless you know
2912  *      that the checksum difference is zero (e.g., a valid IP header)
2913  *      or you are setting ip_summed to CHECKSUM_NONE.
2914  */
2915 static inline unsigned char *skb_push_rcsum(struct sk_buff *skb,
2916                                             unsigned int len)
2917 {
2918         skb_push(skb, len);
2919         skb_postpush_rcsum(skb, skb->data, len);
2920         return skb->data;
2921 }
2922 
2923 /**
2924  *      pskb_trim_rcsum - trim received skb and update checksum
2925  *      @skb: buffer to trim
2926  *      @len: new length
2927  *
2928  *      This is exactly the same as pskb_trim except that it ensures the
2929  *      checksum of received packets are still valid after the operation.
2930  */
2931 
2932 static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
2933 {
2934         if (likely(len >= skb->len))
2935                 return 0;
2936         if (skb->ip_summed == CHECKSUM_COMPLETE)
2937                 skb->ip_summed = CHECKSUM_NONE;
2938         return __pskb_trim(skb, len);
2939 }
2940 
2941 #define skb_queue_walk(queue, skb) \
2942                 for (skb = (queue)->next;                                       \
2943                      skb != (struct sk_buff *)(queue);                          \
2944                      skb = skb->next)
2945 
2946 #define skb_queue_walk_safe(queue, skb, tmp)                                    \
2947                 for (skb = (queue)->next, tmp = skb->next;                      \
2948                      skb != (struct sk_buff *)(queue);                          \
2949                      skb = tmp, tmp = skb->next)
2950 
2951 #define skb_queue_walk_from(queue, skb)                                         \
2952                 for (; skb != (struct sk_buff *)(queue);                        \
2953                      skb = skb->next)
2954 
2955 #define skb_queue_walk_from_safe(queue, skb, tmp)                               \
2956                 for (tmp = skb->next;                                           \
2957                      skb != (struct sk_buff *)(queue);                          \
2958                      skb = tmp, tmp = skb->next)
2959 
2960 #define skb_queue_reverse_walk(queue, skb) \
2961                 for (skb = (queue)->prev;                                       \
2962                      skb != (struct sk_buff *)(queue);                          \
2963                      skb = skb->prev)
2964 
2965 #define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
2966                 for (skb = (queue)->prev, tmp = skb->prev;                      \
2967                      skb != (struct sk_buff *)(queue);                          \
2968                      skb = tmp, tmp = skb->prev)
2969 
2970 #define skb_queue_reverse_walk_from_safe(queue, skb, tmp)                       \
2971                 for (tmp = skb->prev;                                           \
2972                      skb != (struct sk_buff *)(queue);                          \
2973                      skb = tmp, tmp = skb->prev)
2974 
2975 static inline bool skb_has_frag_list(const struct sk_buff *skb)
2976 {
2977         return skb_shinfo(skb)->frag_list != NULL;
2978 }
2979 
2980 static inline void skb_frag_list_init(struct sk_buff *skb)
2981 {
2982         skb_shinfo(skb)->frag_list = NULL;
2983 }
2984 
2985 #define skb_walk_frags(skb, iter)       \
2986         for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
2987 
2988 
2989 int __skb_wait_for_more_packets(struct sock *sk, int *err, long *timeo_p,
2990                                 const struct sk_buff *skb);
2991 struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned flags,
2992                                         int *peeked, int *off, int *err,
2993                                         struct sk_buff **last);
2994 struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
2995                                     int *peeked, int *off, int *err);
2996 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
2997                                   int *err);
2998 unsigned int datagram_poll(struct file *file, struct socket *sock,
2999                            struct poll_table_struct *wait);
3000 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
3001                            struct iov_iter *to, int size);
3002 static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset,
3003                                         struct msghdr *msg, int size)
3004 {
3005         return skb_copy_datagram_iter(from, offset, &msg->msg_iter, size);
3006 }
3007 int skb_copy_and_csum_datagram_msg(struct sk_buff *skb, int hlen,
3008                                    struct msghdr *msg);
3009 int skb_copy_datagram_from_iter(struct sk_buff *skb, int offset,
3010                                  struct iov_iter *from, int len);
3011 int zerocopy_sg_from_iter(struct sk_buff *skb, struct iov_iter *frm);
3012 void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
3013 void __skb_free_datagram_locked(struct sock *sk, struct sk_buff *skb, int len);
3014 static inline void skb_free_datagram_locked(struct sock *sk,
3015                                             struct sk_buff *skb)
3016 {
3017         __skb_free_datagram_locked(sk, skb, 0);
3018 }
3019 int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags);
3020 int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len);
3021 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len);
3022 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset, u8 *to,
3023                               int len, __wsum csum);
3024 ssize_t skb_socket_splice(struct sock *sk,
3025                           struct pipe_inode_info *pipe,
3026                           struct splice_pipe_desc *spd);
3027 int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
3028                     struct pipe_inode_info *pipe, unsigned int len,
3029                     unsigned int flags,
3030                     ssize_t (*splice_cb)(struct sock *,
3031                                          struct pipe_inode_info *,
3032                                          struct splice_pipe_desc *));
3033 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
3034 unsigned int skb_zerocopy_headlen(const struct sk_buff *from);
3035 int skb_zerocopy(struct sk_buff *to, struct sk_buff *from,
3036                  int len, int hlen);
3037 void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len);
3038 int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen);
3039 void skb_scrub_packet(struct sk_buff *skb, bool xnet);
3040 unsigned int skb_gso_transport_seglen(const struct sk_buff *skb);
3041 bool skb_gso_validate_mtu(const struct sk_buff *skb, unsigned int mtu);
3042 struct sk_buff *skb_segment(struct sk_buff *skb, netdev_features_t features);
3043 struct sk_buff *skb_vlan_untag(struct sk_buff *skb);
3044 int skb_ensure_writable(struct sk_buff *skb, int write_len);
3045 int skb_vlan_pop(struct sk_buff *skb);
3046 int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci);
3047 struct sk_buff *pskb_extract(struct sk_buff *skb, int off, int to_copy,
3048                              gfp_t gfp);
3049 
3050 static inline int memcpy_from_msg(void *data, struct msghdr *msg, int len)
3051 {
3052         return copy_from_iter(data, len, &msg->msg_iter) == len ? 0 : -EFAULT;
3053 }
3054 
3055 static inline int memcpy_to_msg(struct msghdr *msg, void *data, int len)
3056 {
3057         return copy_to_iter(data, len, &msg->msg_iter) == len ? 0 : -EFAULT;
3058 }
3059 
3060 struct skb_checksum_ops {
3061         __wsum (*update)(const void *mem, int len, __wsum wsum);
3062         __wsum (*combine)(__wsum csum, __wsum csum2, int offset, int len);
3063 };
3064 
3065 __wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
3066                       __wsum csum, const struct skb_checksum_ops *ops);
3067 __wsum skb_checksum(const struct sk_buff *skb, int offset, int len,
3068                     __wsum csum);
3069 
3070 static inline void * __must_check
3071 __skb_header_pointer(const struct sk_buff *skb, int offset,
3072                      int len, void *data, int hlen, void *buffer)
3073 {
3074         if (hlen - offset >= len)
3075                 return data + offset;
3076 
3077         if (!skb ||
3078             skb_copy_bits(skb, offset, buffer, len) < 0)
3079                 return NULL;
3080 
3081         return buffer;
3082 }
3083 
3084 static inline void * __must_check
3085 skb_header_pointer(const struct sk_buff *skb, int offset, int len, void *buffer)
3086 {
3087         return __skb_header_pointer(skb, offset, len, skb->data,
3088                                     skb_headlen(skb), buffer);
3089 }
3090 
3091 /**
3092  *      skb_needs_linearize - check if we need to linearize a given skb
3093  *                            depending on the given device features.
3094  *      @skb: socket buffer to check
3095  *      @features: net device features
3096  *
3097  *      Returns true if either:
3098  *      1. skb has frag_list and the device doesn't support FRAGLIST, or
3099  *      2. skb is fragmented and the device does not support SG.
3100  */
3101 static inline bool skb_needs_linearize(struct sk_buff *skb,
3102                                        netdev_features_t features)
3103 {
3104         return skb_is_nonlinear(skb) &&
3105                ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) ||
3106                 (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG)));
3107 }
3108 
3109 static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
3110                                              void *to,
3111                                              const unsigned int len)
3112 {
3113         memcpy(to, skb->data, len);
3114 }
3115 
3116 static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
3117                                                     const int offset, void *to,
3118                                                     const unsigned int len)
3119 {
3120         memcpy(to, skb->data + offset, len);
3121 }
3122 
3123 static inline void skb_copy_to_linear_data(struct sk_buff *skb,
3124                                            const void *from,
3125                                            const unsigned int len)
3126 {
3127         memcpy(skb->data, from, len);
3128 }
3129 
3130 static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
3131                                                   const int offset,
3132                                                   const void *from,
3133                                                   const unsigned int len)
3134 {
3135         memcpy(skb->data + offset, from, len);
3136 }
3137 
3138 void skb_init(void);
3139 
3140 static inline ktime_t skb_get_ktime(const struct sk_buff *skb)
3141 {
3142         return skb->tstamp;
3143 }
3144 
3145 /**
3146  *      skb_get_timestamp - get timestamp from a skb
3147  *      @skb: skb to get stamp from
3148  *      @stamp: pointer to struct timeval to store stamp in
3149  *
3150  *      Timestamps are stored in the skb as offsets to a base timestamp.
3151  *      This function converts the offset back to a struct timeval and stores
3152  *      it in stamp.
3153  */
3154 static inline void skb_get_timestamp(const struct sk_buff *skb,
3155                                      struct timeval *stamp)
3156 {
3157         *stamp = ktime_to_timeval(skb->tstamp);
3158 }
3159 
3160 static inline void skb_get_timestampns(const struct sk_buff *skb,
3161                                        struct timespec *stamp)
3162 {
3163         *stamp = ktime_to_timespec(skb->tstamp);
3164 }
3165 
3166 static inline void __net_timestamp(struct sk_buff *skb)
3167 {
3168         skb->tstamp = ktime_get_real();
3169 }
3170 
3171 static inline ktime_t net_timedelta(ktime_t t)
3172 {
3173         return ktime_sub(ktime_get_real(), t);
3174 }
3175 
3176 static inline ktime_t net_invalid_timestamp(void)
3177 {
3178         return ktime_set(0, 0);
3179 }
3180 
3181 struct sk_buff *skb_clone_sk(struct sk_buff *skb);
3182 
3183 #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
3184 
3185 void skb_clone_tx_timestamp(struct sk_buff *skb);
3186 bool skb_defer_rx_timestamp(struct sk_buff *skb);
3187 
3188 #else /* CONFIG_NETWORK_PHY_TIMESTAMPING */
3189 
3190 static inline void skb_clone_tx_timestamp(struct sk_buff *skb)
3191 {
3192 }
3193 
3194 static inline bool skb_defer_rx_timestamp(struct sk_buff *skb)
3195 {
3196         return false;
3197 }
3198 
3199 #endif /* !CONFIG_NETWORK_PHY_TIMESTAMPING */
3200 
3201 /**
3202  * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps
3203  *
3204  * PHY drivers may accept clones of transmitted packets for
3205  * timestamping via their phy_driver.txtstamp method. These drivers
3206  * must call this function to return the skb back to the stack with a
3207  * timestamp.
3208  *
3209  * @skb: clone of the the original outgoing packet
3210  * @hwtstamps: hardware time stamps
3211  *
3212  */
3213 void skb_complete_tx_timestamp(struct sk_buff *skb,
3214                                struct skb_shared_hwtstamps *hwtstamps);
3215 
3216 void __skb_tstamp_tx(struct sk_buff *orig_skb,
3217                      struct skb_shared_hwtstamps *hwtstamps,
3218                      struct sock *sk, int tstype);
3219 
3220 /**
3221  * skb_tstamp_tx - queue clone of skb with send time stamps
3222  * @orig_skb:   the original outgoing packet
3223  * @hwtstamps:  hardware time stamps, may be NULL if not available
3224  *
3225  * If the skb has a socket associated, then this function clones the
3226  * skb (thus sharing the actual data and optional structures), stores
3227  * the optional hardware time stamping information (if non NULL) or
3228  * generates a software time stamp (otherwise), then queues the clone
3229  * to the error queue of the socket.  Errors are silently ignored.
3230  */
3231 void skb_tstamp_tx(struct sk_buff *orig_skb,
3232                    struct skb_shared_hwtstamps *hwtstamps);
3233 
3234 static inline void sw_tx_timestamp(struct sk_buff *skb)
3235 {
3236         if (skb_shinfo(skb)->tx_flags & SKBTX_SW_TSTAMP &&
3237             !(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
3238                 skb_tstamp_tx(skb, NULL);
3239 }
3240 
3241 /**
3242  * skb_tx_timestamp() - Driver hook for transmit timestamping
3243  *
3244  * Ethernet MAC Drivers should call this function in their hard_xmit()
3245  * function immediately before giving the sk_buff to the MAC hardware.
3246  *
3247  * Specifically, one should make absolutely sure that this function is
3248  * called before TX completion of this packet can trigger.  Otherwise
3249  * the packet could potentially already be freed.
3250  *
3251  * @skb: A socket buffer.
3252  */
3253 static inline void skb_tx_timestamp(struct sk_buff *skb)
3254 {
3255         skb_clone_tx_timestamp(skb);
3256         sw_tx_timestamp(skb);
3257 }
3258 
3259 /**
3260  * skb_complete_wifi_ack - deliver skb with wifi status
3261  *
3262  * @skb: the original outgoing packet
3263  * @acked: ack status
3264  *
3265  */
3266 void skb_complete_wifi_ack(struct sk_buff *skb, bool acked);
3267 
3268 __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
3269 __sum16 __skb_checksum_complete(struct sk_buff *skb);
3270 
3271 static inline int skb_csum_unnecessary(const struct sk_buff *skb)
3272 {
3273         return ((skb->ip_summed == CHECKSUM_UNNECESSARY) ||
3274                 skb->csum_valid ||
3275                 (skb->ip_summed == CHECKSUM_PARTIAL &&
3276                  skb_checksum_start_offset(skb) >= 0));
3277 }
3278 
3279 /**
3280  *      skb_checksum_complete - Calculate checksum of an entire packet
3281  *      @skb: packet to process
3282  *
3283  *      This function calculates the checksum over the entire packet plus
3284  *      the value of skb->csum.  The latter can be used to supply the
3285  *      checksum of a pseudo header as used by TCP/UDP.  It returns the
3286  *      checksum.
3287  *
3288  *      For protocols that contain complete checksums such as ICMP/TCP/UDP,
3289  *      this function can be used to verify that checksum on received
3290  *      packets.  In that case the function should return zero if the
3291  *      checksum is correct.  In particular, this function will return zero
3292  *      if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
3293  *      hardware has already verified the correctness of the checksum.
3294  */
3295 static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
3296 {
3297         return skb_csum_unnecessary(skb) ?
3298                0 : __skb_checksum_complete(skb);
3299 }
3300 
3301 static inline void __skb_decr_checksum_unnecessary(struct sk_buff *skb)
3302 {
3303         if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
3304                 if (skb->csum_level == 0)
3305                         skb->ip_summed = CHECKSUM_NONE;
3306                 else
3307                         skb->csum_level--;
3308         }
3309 }
3310 
3311 static inline void __skb_incr_checksum_unnecessary(struct sk_buff *skb)
3312 {
3313         if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
3314                 if (skb->csum_level < SKB_MAX_CSUM_LEVEL)
3315                         skb->csum_level++;
3316         } else if (skb->ip_summed == CHECKSUM_NONE) {
3317                 skb->ip_summed = CHECKSUM_UNNECESSARY;
3318                 skb->csum_level = 0;
3319         }
3320 }
3321 
3322 static inline void __skb_mark_checksum_bad(struct sk_buff *skb)
3323 {
3324         /* Mark current checksum as bad (typically called from GRO
3325          * path). In the case that ip_summed is CHECKSUM_NONE
3326          * this must be the first checksum encountered in the packet.
3327          * When ip_summed is CHECKSUM_UNNECESSARY, this is the first
3328          * checksum after the last one validated. For UDP, a zero
3329          * checksum can not be marked as bad.
3330          */
3331 
3332         if (skb->ip_summed == CHECKSUM_NONE ||
3333             skb->ip_summed == CHECKSUM_UNNECESSARY)
3334                 skb->csum_bad = 1;
3335 }
3336 
3337 /* Check if we need to perform checksum complete validation.
3338  *
3339  * Returns true if checksum complete is needed, false otherwise
3340  * (either checksum is unnecessary or zero checksum is allowed).
3341  */
3342 static inline bool __skb_checksum_validate_needed(struct sk_buff *skb,
3343                                                   bool zero_okay,
3344                                                   __sum16 check)
3345 {
3346         if (skb_csum_unnecessary(skb) || (zero_okay && !check)) {
3347                 skb->csum_valid = 1;
3348                 __skb_decr_checksum_unnecessary(skb);
3349                 return false;
3350         }
3351 
3352         return true;
3353 }
3354 
3355 /* For small packets <= CHECKSUM_BREAK peform checksum complete directly
3356  * in checksum_init.
3357  */
3358 #define CHECKSUM_BREAK 76
3359 
3360 /* Unset checksum-complete
3361  *
3362  * Unset checksum complete can be done when packet is being modified
3363  * (uncompressed for instance) and checksum-complete value is
3364  * invalidated.
3365  */
3366 static inline void skb_checksum_complete_unset(struct sk_buff *skb)
3367 {
3368         if (skb->ip_summed == CHECKSUM_COMPLETE)
3369                 skb->ip_summed = CHECKSUM_NONE;
3370 }
3371 
3372 /* Validate (init) checksum based on checksum complete.
3373  *
3374  * Return values:
3375  *   0: checksum is validated or try to in skb_checksum_complete. In the latter
3376  *      case the ip_summed will not be CHECKSUM_UNNECESSARY and the pseudo
3377  *      checksum is stored in skb->csum for use in __skb_checksum_complete
3378  *   non-zero: value of invalid checksum
3379  *
3380  */
3381 static inline __sum16 __skb_checksum_validate_complete(struct sk_buff *skb,
3382                                                        bool complete,
3383                                                        __wsum psum)
3384 {
3385         if (skb->ip_summed == CHECKSUM_COMPLETE) {
3386                 if (!csum_fold(csum_add(psum, skb->csum))) {
3387                         skb->csum_valid = 1;
3388                         return 0;
3389                 }
3390         } else if (skb->csum_bad) {
3391                 /* ip_summed == CHECKSUM_NONE in this case */
3392                 return (__force __sum16)1;
3393         }
3394 
3395         skb->csum = psum;
3396 
3397         if (complete || skb->len <= CHECKSUM_BREAK) {
3398                 __sum16 csum;
3399 
3400                 csum = __skb_checksum_complete(skb);
3401                 skb->csum_valid = !csum;
3402                 return csum;
3403         }
3404 
3405         return 0;
3406 }
3407 
3408 static inline __wsum null_compute_pseudo(struct sk_buff *skb, int proto)
3409 {
3410         return 0;
3411 }
3412 
3413 /* Perform checksum validate (init). Note that this is a macro since we only
3414  * want to calculate the pseudo header which is an input function if necessary.
3415  * First we try to validate without any computation (checksum unnecessary) and
3416  * then calculate based on checksum complete calling the function to compute
3417  * pseudo header.
3418  *
3419  * Return values:
3420  *   0: checksum is validated or try to in skb_checksum_complete
3421  *   non-zero: value of invalid checksum
3422  */
3423 #define __skb_checksum_validate(skb, proto, complete,                   \
3424                                 zero_okay, check, compute_pseudo)       \
3425 ({                                                                      \
3426         __sum16 __ret = 0;                                              \
3427         skb->csum_valid = 0;                                            \
3428         if (__skb_checksum_validate_needed(skb, zero_okay, check))      \
3429                 __ret = __skb_checksum_validate_complete(skb,           \
3430                                 complete, compute_pseudo(skb, proto));  \
3431         __ret;                                                          \
3432 })
3433 
3434 #define skb_checksum_init(skb, proto, compute_pseudo)                   \
3435         __skb_checksum_validate(skb, proto, false, false, 0, compute_pseudo)
3436 
3437 #define skb_checksum_init_zero_check(skb, proto, check, compute_pseudo) \
3438         __skb_checksum_validate(skb, proto, false, true, check, compute_pseudo)
3439 
3440 #define skb_checksum_validate(skb, proto, compute_pseudo)               \
3441         __skb_checksum_validate(skb, proto, true, false, 0, compute_pseudo)
3442 
3443 #define skb_checksum_validate_zero_check(skb, proto, check,             \
3444                                          compute_pseudo)                \
3445         __skb_checksum_validate(skb, proto, true, true, check, compute_pseudo)
3446 
3447 #define skb_checksum_simple_validate(skb)                               \
3448         __skb_checksum_validate(skb, 0, true, false, 0, null_compute_pseudo)
3449 
3450 static inline bool __skb_checksum_convert_check(struct sk_buff *skb)
3451 {
3452         return (skb->ip_summed == CHECKSUM_NONE &&
3453                 skb->csum_valid && !skb->csum_bad);
3454 }
3455 
3456 static inline void __skb_checksum_convert(struct sk_buff *skb,
3457                                           __sum16 check, __wsum pseudo)
3458 {
3459         skb->csum = ~pseudo;
3460         skb->ip_summed = CHECKSUM_COMPLETE;
3461 }
3462 
3463 #define skb_checksum_try_convert(skb, proto, check, compute_pseudo)     \
3464 do {                                                                    \
3465         if (__skb_checksum_convert_check(skb))                          \
3466                 __skb_checksum_convert(skb, check,                      \
3467                                        compute_pseudo(skb, proto));     \
3468 } while (0)
3469 
3470 static inline void skb_remcsum_adjust_partial(struct sk_buff *skb, void *ptr,
3471                                               u16 start, u16 offset)
3472 {
3473         skb->ip_summed = CHECKSUM_PARTIAL;
3474         skb->csum_start = ((unsigned char *)ptr + start) - skb->head;
3475         skb->csum_offset = offset - start;
3476 }
3477 
3478 /* Update skbuf and packet to reflect the remote checksum offload operation.
3479  * When called, ptr indicates the starting point for skb->csum when
3480  * ip_summed is CHECKSUM_COMPLETE. If we need create checksum complete
3481  * here, skb_postpull_rcsum is done so skb->csum start is ptr.
3482  */
3483 static inline void skb_remcsum_process(struct sk_buff *skb, void *ptr,
3484                                        int start, int offset, bool nopartial)
3485 {
3486         __wsum delta;
3487 
3488         if (!nopartial) {
3489                 skb_remcsum_adjust_partial(skb, ptr, start, offset);
3490                 return;
3491         }
3492 
3493          if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
3494                 __skb_checksum_complete(skb);
3495                 skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);
3496         }
3497 
3498         delta = remcsum_adjust(ptr, skb->csum, start, offset);
3499 
3500         /* Adjust skb->csum since we changed the packet */
3501         skb->csum = csum_add(skb->csum, delta);
3502 }
3503 
3504 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
3505 void nf_conntrack_destroy(struct nf_conntrack *nfct);
3506 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
3507 {
3508         if (nfct && atomic_dec_and_test(&nfct->use))
3509                 nf_conntrack_destroy(nfct);
3510 }
3511 static inline void nf_conntrack_get(struct nf_conntrack *nfct)
3512 {
3513         if (nfct)
3514                 atomic_inc(&nfct->use);
3515 }
3516 #endif
3517 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
3518 static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
3519 {
3520         if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
3521                 kfree(nf_bridge);
3522 }
3523 static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
3524 {
3525         if (nf_bridge)
3526                 atomic_inc(&nf_bridge->use);
3527 }
3528 #endif /* CONFIG_BRIDGE_NETFILTER */
3529 static inline void nf_reset(struct sk_buff *skb)
3530 {
3531 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
3532         nf_conntrack_put(skb->nfct);
3533         skb->nfct = NULL;
3534 #endif
3535 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
3536         nf_bridge_put(skb->nf_bridge);
3537         skb->nf_bridge = NULL;
3538 #endif
3539 }
3540 
3541 static inline void nf_reset_trace(struct sk_buff *skb)
3542 {
3543 #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) || defined(CONFIG_NF_TABLES)
3544         skb->nf_trace = 0;
3545 #endif
3546 }
3547 
3548 /* Note: This doesn't put any conntrack and bridge info in dst. */
3549 static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src,
3550                              bool copy)
3551 {
3552 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
3553         dst->nfct = src->nfct;
3554         nf_conntrack_get(src->nfct);
3555         if (copy)
3556                 dst->nfctinfo = src->nfctinfo;
3557 #endif
3558 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
3559         dst->nf_bridge  = src->nf_bridge;
3560         nf_bridge_get(src->nf_bridge);
3561 #endif
3562 #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) || defined(CONFIG_NF_TABLES)
3563         if (copy)
3564                 dst->nf_trace = src->nf_trace;
3565 #endif
3566 }
3567 
3568 static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
3569 {
3570 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
3571         nf_conntrack_put(dst->nfct);
3572 #endif
3573 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
3574         nf_bridge_put(dst->nf_bridge);
3575 #endif
3576         __nf_copy(dst, src, true);
3577 }
3578 
3579 #ifdef CONFIG_NETWORK_SECMARK
3580 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
3581 {
3582         to->secmark = from->secmark;
3583 }
3584 
3585 static inline void skb_init_secmark(struct sk_buff *skb)
3586 {
3587         skb->secmark = 0;
3588 }
3589 #else
3590 static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
3591 { }
3592 
3593 static inline void skb_init_secmark(struct sk_buff *skb)
3594 { }
3595 #endif
3596 
3597 static inline bool skb_irq_freeable(const struct sk_buff *skb)
3598 {
3599         return !skb->destructor &&
3600 #if IS_ENABLED(CONFIG_XFRM)
3601                 !skb->sp &&
3602 #endif
3603 #if IS_ENABLED(CONFIG_NF_CONNTRACK)
3604                 !skb->nfct &&
3605 #endif
3606                 !skb->_skb_refdst &&
3607                 !skb_has_frag_list(skb);
3608 }
3609 
3610 static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
3611 {
3612         skb->queue_mapping = queue_mapping;
3613 }
3614 
3615 static inline u16 skb_get_queue_mapping(const struct sk_buff *skb)
3616 {
3617         return skb->queue_mapping;
3618 }
3619 
3620 static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
3621 {
3622         to->queue_mapping = from->queue_mapping;
3623 }
3624 
3625 static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue)
3626 {
3627         skb->queue_mapping = rx_queue + 1;
3628 }
3629 
3630 static inline u16 skb_get_rx_queue(const struct sk_buff *skb)
3631 {
3632         return skb->queue_mapping - 1;
3633 }
3634 
3635 static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
3636 {
3637         return skb->queue_mapping != 0;
3638 }
3639 
3640 static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
3641 {
3642 #ifdef CONFIG_XFRM
3643         return skb->sp;
3644 #else
3645         return NULL;
3646 #endif
3647 }
3648 
3649 /* Keeps track of mac header offset relative to skb->head.
3650  * It is useful for TSO of Tunneling protocol. e.g. GRE.
3651  * For non-tunnel skb it points to skb_mac_header() and for
3652  * tunnel skb it points to outer mac header.
3653  * Keeps track of level of encapsulation of network headers.
3654  */
3655 struct skb_gso_cb {
3656         union {
3657                 int     mac_offset;
3658                 int     data_offset;
3659         };
3660         int     encap_level;
3661         __wsum  csum;
3662         __u16   csum_start;
3663 };
3664 #define SKB_SGO_CB_OFFSET       32
3665 #define SKB_GSO_CB(skb) ((struct skb_gso_cb *)((skb)->cb + SKB_SGO_CB_OFFSET))
3666 
3667 static inline int skb_tnl_header_len(const struct sk_buff *inner_skb)
3668 {
3669         return (skb_mac_header(inner_skb) - inner_skb->head) -
3670                 SKB_GSO_CB(inner_skb)->mac_offset;
3671 }
3672 
3673 static inline int gso_pskb_expand_head(struct sk_buff *skb, int extra)
3674 {
3675         int new_headroom, headroom;
3676         int ret;
3677 
3678         headroom = skb_headroom(skb);
3679         ret = pskb_expand_head(skb, extra, 0, GFP_ATOMIC);
3680         if (ret)
3681                 return ret;
3682 
3683         new_headroom = skb_headroom(skb);
3684         SKB_GSO_CB(skb)->mac_offset += (new_headroom - headroom);
3685         return 0;
3686 }
3687 
3688 static inline void gso_reset_checksum(struct sk_buff *skb, __wsum res)
3689 {
3690         /* Do not update partial checksums if remote checksum is enabled. */
3691         if (skb->remcsum_offload)
3692                 return;
3693 
3694         SKB_GSO_CB(skb)->csum = res;
3695         SKB_GSO_CB(skb)->csum_start = skb_checksum_start(skb) - skb->head;
3696 }
3697 
3698 /* Compute the checksum for a gso segment. First compute the checksum value
3699  * from the start of transport header to SKB_GSO_CB(skb)->csum_start, and
3700  * then add in skb->csum (checksum from csum_start to end of packet).
3701  * skb->csum and csum_start are then updated to reflect the checksum of the
3702  * resultant packet starting from the transport header-- the resultant checksum
3703  * is in the res argument (i.e. normally zero or ~ of checksum of a pseudo
3704  * header.
3705  */
3706 static inline __sum16 gso_make_checksum(struct sk_buff *skb, __wsum res)
3707 {
3708         unsigned char *csum_start = skb_transport_header(skb);
3709         int plen = (skb->head + SKB_GSO_CB(skb)->csum_start) - csum_start;
3710         __wsum partial = SKB_GSO_CB(skb)->csum;
3711 
3712         SKB_GSO_CB(skb)->csum = res;
3713         SKB_GSO_CB(skb)->csum_start = csum_start - skb->head;
3714 
3715         return csum_fold(csum_partial(csum_start, plen, partial));
3716 }
3717 
3718 static inline bool skb_is_gso(const struct sk_buff *skb)
3719 {
3720         return skb_shinfo(skb)->gso_size;
3721 }
3722 
3723 /* Note: Should be called only if skb_is_gso(skb) is true */
3724 static inline bool skb_is_gso_v6(const struct sk_buff *skb)
3725 {
3726         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
3727 }
3728 
3729 void __skb_warn_lro_forwarding(const struct sk_buff *skb);
3730 
3731 static inline bool skb_warn_if_lro(const struct sk_buff *skb)
3732 {
3733         /* LRO sets gso_size but not gso_type, whereas if GSO is really
3734          * wanted then gso_type will be set. */
3735         const struct skb_shared_info *shinfo = skb_shinfo(skb);
3736 
3737         if (skb_is_nonlinear(skb) && shinfo->gso_size != 0 &&
3738             unlikely(shinfo->gso_type == 0)) {
3739                 __skb_warn_lro_forwarding(skb);
3740                 return true;
3741         }
3742         return false;
3743 }
3744 
3745 static inline void skb_forward_csum(struct sk_buff *skb)
3746 {
3747         /* Unfortunately we don't support this one.  Any brave souls? */
3748         if (skb->ip_summed == CHECKSUM_COMPLETE)
3749                 skb->ip_summed = CHECKSUM_NONE;
3750 }
3751 
3752 /**
3753  * skb_checksum_none_assert - make sure skb ip_summed is CHECKSUM_NONE
3754  * @skb: skb to check
3755  *
3756  * fresh skbs have their ip_summed set to CHECKSUM_NONE.
3757  * Instead of forcing ip_summed to CHECKSUM_NONE, we can
3758  * use this helper, to document places where we make this assertion.
3759  */
3760 static inline void skb_checksum_none_assert(const struct sk_buff *skb)
3761 {
3762 #ifdef DEBUG
3763         BUG_ON(skb->ip_summed != CHECKSUM_NONE);
3764 #endif
3765 }
3766 
3767 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
3768 
3769 int skb_checksum_setup(struct sk_buff *skb, bool recalculate);
3770 struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
3771                                      unsigned int transport_len,
3772                                      __sum16(*skb_chkf)(struct sk_buff *skb));
3773 
3774 /**
3775  * skb_head_is_locked - Determine if the skb->head is locked down
3776  * @skb: skb to check
3777  *
3778  * The head on skbs build around a head frag can be removed if they are
3779  * not cloned.  This function returns true if the skb head is locked down
3780  * due to either being allocated via kmalloc, or by being a clone with
3781  * multiple references to the head.
3782  */
3783 static inline bool skb_head_is_locked(const struct sk_buff *skb)
3784 {
3785         return !skb->head_frag || skb_cloned(skb);
3786 }
3787 
3788 /**
3789  * skb_gso_network_seglen - Return length of individual segments of a gso packet
3790  *
3791  * @skb: GSO skb
3792  *
3793  * skb_gso_network_seglen is used to determine the real size of the
3794  * individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP).
3795  *
3796  * The MAC/L2 header is not accounted for.
3797  */
3798 static inline unsigned int skb_gso_network_seglen(const struct sk_buff *skb)
3799 {
3800         unsigned int hdr_len = skb_transport_header(skb) -
3801                                skb_network_header(skb);
3802         return hdr_len + skb_gso_transport_seglen(skb);
3803 }
3804 
3805 /* Local Checksum Offload.
3806  * Compute outer checksum based on the assumption that the
3807  * inner checksum will be offloaded later.
3808  * See Documentation/networking/checksum-offloads.txt for
3809  * explanation of how this works.
3810  * Fill in outer checksum adjustment (e.g. with sum of outer
3811  * pseudo-header) before calling.
3812  * Also ensure that inner checksum is in linear data area.
3813  */
3814 static inline __wsum lco_csum(struct sk_buff *skb)
3815 {
3816         unsigned char *csum_start = skb_checksum_start(skb);
3817         unsigned char *l4_hdr = skb_transport_header(skb);
3818         __wsum partial;
3819 
3820         /* Start with complement of inner checksum adjustment */
3821         partial = ~csum_unfold(*(__force __sum16 *)(csum_start +
3822                                                     skb->csum_offset));
3823 
3824         /* Add in checksum of our headers (incl. outer checksum
3825          * adjustment filled in by caller) and return result.
3826          */
3827         return csum_partial(l4_hdr, csum_start - l4_hdr, partial);
3828 }
3829 
3830 #endif  /* __KERNEL__ */
3831 #endif  /* _LINUX_SKBUFF_H */
3832 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us