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