cregit-Linux how code gets into the kernel

Release 4.12 include/linux/skbuff.h

Directory: include/linux
/*
 *      Definitions for the 'struct sk_buff' memory handlers.
 *
 *      Authors:
 *              Alan Cox, <gw4pts@gw4pts.ampr.org>
 *              Florian La Roche, <rzsfl@rz.uni-sb.de>
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */

#ifndef _LINUX_SKBUFF_H

#define _LINUX_SKBUFF_H

#include <linux/kernel.h>
#include <linux/kmemcheck.h>
#include <linux/compiler.h>
#include <linux/time.h>
#include <linux/bug.h>
#include <linux/cache.h>
#include <linux/rbtree.h>
#include <linux/socket.h>

#include <linux/atomic.h>
#include <asm/types.h>
#include <linux/spinlock.h>
#include <linux/net.h>
#include <linux/textsearch.h>
#include <net/checksum.h>
#include <linux/rcupdate.h>
#include <linux/hrtimer.h>
#include <linux/dma-mapping.h>
#include <linux/netdev_features.h>
#include <linux/sched.h>
#include <linux/sched/clock.h>
#include <net/flow_dissector.h>
#include <linux/splice.h>
#include <linux/in6.h>
#include <linux/if_packet.h>
#include <net/flow.h>

/* The interface for checksum offload between the stack and networking drivers
 * is as follows...
 *
 * A. IP checksum related features
 *
 * Drivers advertise checksum offload capabilities in the features of a device.
 * From the stack's point of view these are capabilities offered by the driver,
 * a driver typically only advertises features that it is capable of offloading
 * to its device.
 *
 * The checksum related features are:
 *
 *      NETIF_F_HW_CSUM - The driver (or its device) is able to compute one
 *                        IP (one's complement) checksum for any combination
 *                        of protocols or protocol layering. The checksum is
 *                        computed and set in a packet per the CHECKSUM_PARTIAL
 *                        interface (see below).
 *
 *      NETIF_F_IP_CSUM - Driver (device) is only able to checksum plain
 *                        TCP or UDP packets over IPv4. These are specifically
 *                        unencapsulated packets of the form IPv4|TCP or
 *                        IPv4|UDP where the Protocol field in the IPv4 header
 *                        is TCP or UDP. The IPv4 header may contain IP options
 *                        This feature cannot be set in features for a device
 *                        with NETIF_F_HW_CSUM also set. This feature is being
 *                        DEPRECATED (see below).
 *
 *      NETIF_F_IPV6_CSUM - Driver (device) is only able to checksum plain
 *                        TCP or UDP packets over IPv6. These are specifically
 *                        unencapsulated packets of the form IPv6|TCP or
 *                        IPv4|UDP where the Next Header field in the IPv6
 *                        header is either TCP or UDP. IPv6 extension headers
 *                        are not supported with this feature. This feature
 *                        cannot be set in features for a device with
 *                        NETIF_F_HW_CSUM also set. This feature is being
 *                        DEPRECATED (see below).
 *
 *      NETIF_F_RXCSUM - Driver (device) performs receive checksum offload.
 *                       This flag is used only used to disable the RX checksum
 *                       feature for a device. The stack will accept receive
 *                       checksum indication in packets received on a device
 *                       regardless of whether NETIF_F_RXCSUM is set.
 *
 * B. Checksumming of received packets by device. Indication of checksum
 *    verification is in set skb->ip_summed. Possible values are:
 *
 * CHECKSUM_NONE:
 *
 *   Device did not checksum this packet e.g. due to lack of capabilities.
 *   The packet contains full (though not verified) checksum in packet but
 *   not in skb->csum. Thus, skb->csum is undefined in this case.
 *
 * CHECKSUM_UNNECESSARY:
 *
 *   The hardware you're dealing with doesn't calculate the full checksum
 *   (as in CHECKSUM_COMPLETE), but it does parse headers and verify checksums
 *   for specific protocols. For such packets it will set CHECKSUM_UNNECESSARY
 *   if their checksums are okay. skb->csum is still undefined in this case
 *   though. A driver or device must never modify the checksum field in the
 *   packet even if checksum is verified.
 *
 *   CHECKSUM_UNNECESSARY is applicable to following protocols:
 *     TCP: IPv6 and IPv4.
 *     UDP: IPv4 and IPv6. A device may apply CHECKSUM_UNNECESSARY to a
 *       zero UDP checksum for either IPv4 or IPv6, the networking stack
 *       may perform further validation in this case.
 *     GRE: only if the checksum is present in the header.
 *     SCTP: indicates the CRC in SCTP header has been validated.
 *
 *   skb->csum_level indicates the number of consecutive checksums found in
 *   the packet minus one that have been verified as CHECKSUM_UNNECESSARY.
 *   For instance if a device receives an IPv6->UDP->GRE->IPv4->TCP packet
 *   and a device is able to verify the checksums for UDP (possibly zero),
 *   GRE (checksum flag is set), and TCP-- skb->csum_level would be set to
 *   two. If the device were only able to verify the UDP checksum and not
 *   GRE, either because it doesn't support GRE checksum of because GRE
 *   checksum is bad, skb->csum_level would be set to zero (TCP checksum is
 *   not considered in this case).
 *
 * CHECKSUM_COMPLETE:
 *
 *   This is the most generic way. The device supplied checksum of the _whole_
 *   packet as seen by netif_rx() and fills out in skb->csum. Meaning, the
 *   hardware doesn't need to parse L3/L4 headers to implement this.
 *
 *   Note: Even if device supports only some protocols, but is able to produce
 *   skb->csum, it MUST use CHECKSUM_COMPLETE, not CHECKSUM_UNNECESSARY.
 *
 * CHECKSUM_PARTIAL:
 *
 *   A checksum is set up to be offloaded to a device as described in the
 *   output description for CHECKSUM_PARTIAL. This may occur on a packet
 *   received directly from another Linux OS, e.g., a virtualized Linux kernel
 *   on the same host, or it may be set in the input path in GRO or remote
 *   checksum offload. For the purposes of checksum verification, the checksum
 *   referred to by skb->csum_start + skb->csum_offset and any preceding
 *   checksums in the packet are considered verified. Any checksums in the
 *   packet that are after the checksum being offloaded are not considered to
 *   be verified.
 *
 * C. Checksumming on transmit for non-GSO. The stack requests checksum offload
 *    in the skb->ip_summed for a packet. Values are:
 *
 * CHECKSUM_PARTIAL:
 *
 *   The driver is required to checksum the packet as seen by hard_start_xmit()
 *   from skb->csum_start up to the end, and to record/write the checksum at
 *   offset skb->csum_start + skb->csum_offset. A driver may verify that the
 *   csum_start and csum_offset values are valid values given the length and
 *   offset of the packet, however they should not attempt to validate that the
 *   checksum refers to a legitimate transport layer checksum-- it is the
 *   purview of the stack to validate that csum_start and csum_offset are set
 *   correctly.
 *
 *   When the stack requests checksum offload for a packet, the driver MUST
 *   ensure that the checksum is set correctly. A driver can either offload the
 *   checksum calculation to the device, or call skb_checksum_help (in the case
 *   that the device does not support offload for a particular checksum).
 *
 *   NETIF_F_IP_CSUM and NETIF_F_IPV6_CSUM are being deprecated in favor of
 *   NETIF_F_HW_CSUM. New devices should use NETIF_F_HW_CSUM to indicate
 *   checksum offload capability. If a  device has limited checksum capabilities
 *   (for instance can only perform NETIF_F_IP_CSUM or NETIF_F_IPV6_CSUM as
 *   described above) a helper function can be called to resolve
 *   CHECKSUM_PARTIAL. The helper functions are skb_csum_off_chk*. The helper
 *   function takes a spec argument that describes the protocol layer that is
 *   supported for checksum offload and can be called for each packet. If a
 *   packet does not match the specification for offload, skb_checksum_help
 *   is called to resolve the checksum.
 *
 * CHECKSUM_NONE:
 *
 *   The skb was already checksummed by the protocol, or a checksum is not
 *   required.
 *
 * CHECKSUM_UNNECESSARY:
 *
 *   This has the same meaning on as CHECKSUM_NONE for checksum offload on
 *   output.
 *
 * CHECKSUM_COMPLETE:
 *   Not used in checksum output. If a driver observes a packet with this value
 *   set in skbuff, if should treat as CHECKSUM_NONE being set.
 *
 * D. Non-IP checksum (CRC) offloads
 *
 *   NETIF_F_SCTP_CRC - This feature indicates that a device is capable of
 *     offloading the SCTP CRC in a packet. To perform this offload the stack
 *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
 *     accordingly. Note the there is no indication in the skbuff that the
 *     CHECKSUM_PARTIAL refers to an SCTP checksum, a driver that supports
 *     both IP checksum offload and SCTP CRC offload must verify which offload
 *     is configured for a packet presumably by inspecting packet headers.
 *
 *   NETIF_F_FCOE_CRC - This feature indicates that a device is capable of
 *     offloading the FCOE CRC in a packet. To perform this offload the stack
 *     will set ip_summed to CHECKSUM_PARTIAL and set csum_start and csum_offset
 *     accordingly. Note the there is no indication in the skbuff that the
 *     CHECKSUM_PARTIAL refers to an FCOE checksum, a driver that supports
 *     both IP checksum offload and FCOE CRC offload must verify which offload
 *     is configured for a packet presumably by inspecting packet headers.
 *
 * E. Checksumming on output with GSO.
 *
 * In the case of a GSO packet (skb_is_gso(skb) is true), checksum offload
 * is implied by the SKB_GSO_* flags in gso_type. Most obviously, if the
 * gso_type is SKB_GSO_TCPV4 or SKB_GSO_TCPV6, TCP checksum offload as
 * part of the GSO operation is implied. If a checksum is being offloaded
 * with GSO then ip_summed is CHECKSUM_PARTIAL, csum_start and csum_offset
 * are set to refer to the outermost checksum being offload (two offloaded
 * checksums are possible with UDP encapsulation).
 */

/* Don't change this without changing skb_csum_unnecessary! */

#define CHECKSUM_NONE		0

#define CHECKSUM_UNNECESSARY	1

#define CHECKSUM_COMPLETE	2

#define CHECKSUM_PARTIAL	3

/* Maximum value in skb->csum_level */

#define SKB_MAX_CSUM_LEVEL	3


#define SKB_DATA_ALIGN(X)	ALIGN(X, SMP_CACHE_BYTES)

#define SKB_WITH_OVERHEAD(X)	\
	((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))

#define SKB_MAX_ORDER(X, ORDER) \
	SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))

#define SKB_MAX_HEAD(X)		(SKB_MAX_ORDER((X), 0))

#define SKB_MAX_ALLOC		(SKB_MAX_ORDER(0, 2))

/* return minimum truesize of one skb containing X bytes of data */

#define SKB_TRUESIZE(X) ((X) +                                          \
                         SKB_DATA_ALIGN(sizeof(struct sk_buff)) +       \
                         SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))

struct net_device;
struct scatterlist;
struct pipe_inode_info;
struct iov_iter;
struct napi_struct;

#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)

struct nf_conntrack {
	
atomic_t use;
};
#endif

#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)

struct nf_bridge_info {
	
atomic_t		use;
	enum {
		
BRNF_PROTO_UNCHANGED,
		
BRNF_PROTO_8021Q,
		
BRNF_PROTO_PPPOE
	
} orig_proto:8;
	
u8			pkt_otherhost:1;
	
u8			in_prerouting:1;
	
u8			bridged_dnat:1;
	
__u16			frag_max_size;
	
struct net_device	*physindev;

	/* always valid & non-NULL from FORWARD on, for physdev match */
	
struct net_device	*physoutdev;
	union {
		/* prerouting: detect dnat in orig/reply direction */
		
__be32          ipv4_daddr;
		
struct in6_addr ipv6_daddr;

		/* after prerouting + nat detected: store original source
                 * mac since neigh resolution overwrites it, only used while
                 * skb is out in neigh layer.
                 */
		
char neigh_header[8];
	};
};
#endif


struct sk_buff_head {
	/* These two members must be first. */
	
struct sk_buff	*next;
	
struct sk_buff	*prev;

	
__u32		qlen;
	
spinlock_t	lock;
};

struct sk_buff;

/* To allow 64K frame to be packed as single skb without frag_list we
 * require 64K/PAGE_SIZE pages plus 1 additional page to allow for
 * buffers which do not start on a page boundary.
 *
 * Since GRO uses frags we allocate at least 16 regardless of page
 * size.
 */
#if (65536/PAGE_SIZE + 1) < 16

#define MAX_SKB_FRAGS 16UL
#else

#define MAX_SKB_FRAGS (65536/PAGE_SIZE + 1)
#endif
extern int sysctl_max_skb_frags;

/* Set skb_shinfo(skb)->gso_size to this in case you want skb_segment to
 * segment using its current segmentation instead.
 */

#define GSO_BY_FRAGS	0xFFFF


typedef struct skb_frag_struct skb_frag_t;


struct skb_frag_struct {
	struct {
		
struct page *p;
	
} page;
#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
	
__u32 page_offset;
	
__u32 size;
#else
	
__u16 page_offset;
	
__u16 size;
#endif
};




static inline unsigned int skb_frag_size(const skb_frag_t *frag)
{
	return frag->size;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet18100.00%1100.00%


Total18100.00%1100.00%






static inline void skb_frag_size_set(skb_frag_t *frag, unsigned int size)
{
	frag->size = size;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet21100.00%1100.00%


Total21100.00%1100.00%






static inline void skb_frag_size_add(skb_frag_t *frag, int delta)
{
	frag->size += delta;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet20100.00%1100.00%


Total20100.00%1100.00%






static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
{
	frag->size -= delta;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet20100.00%1100.00%


Total20100.00%1100.00%




#define HAVE_HW_TIME_STAMP

/**
 * struct skb_shared_hwtstamps - hardware time stamps
 * @hwtstamp:   hardware time stamp transformed into duration
 *              since arbitrary point in time
 *
 * Software time stamps generated by ktime_get_real() are stored in
 * skb->tstamp.
 *
 * hwtstamps can only be compared against other hwtstamps from
 * the same device.
 *
 * This structure is attached to packets as part of the
 * &skb_shared_info. Use skb_hwtstamps() to get a pointer.
 */

struct skb_shared_hwtstamps {
	
ktime_t	hwtstamp;
};

/* Definitions for tx_flags in struct skb_shared_info */
enum {
	/* generate hardware time stamp */
	
SKBTX_HW_TSTAMP = 1 << 0,

	/* generate software time stamp when queueing packet to NIC */
	
SKBTX_SW_TSTAMP = 1 << 1,

	/* device driver is going to provide hardware time stamp */
	
SKBTX_IN_PROGRESS = 1 << 2,

	/* device driver supports TX zero-copy buffers */
	
SKBTX_DEV_ZEROCOPY = 1 << 3,

	/* generate wifi status information (where possible) */
	
SKBTX_WIFI_STATUS = 1 << 4,

	/* This indicates at least one fragment might be overwritten
         * (as in vmsplice(), sendfile() ...)
         * If we need to compute a TX checksum, we'll need to copy
         * all frags to avoid possible bad checksum
         */
	
SKBTX_SHARED_FRAG = 1 << 5,

	/* generate software time stamp when entering packet scheduling */
	
SKBTX_SCHED_TSTAMP = 1 << 6,
};


#define SKBTX_ANY_SW_TSTAMP	(SKBTX_SW_TSTAMP    | \
                                 SKBTX_SCHED_TSTAMP)

#define SKBTX_ANY_TSTAMP	(SKBTX_HW_TSTAMP | SKBTX_ANY_SW_TSTAMP)

/*
 * The callback notifies userspace to release buffers when skb DMA is done in
 * lower device, the skb last reference should be 0 when calling this.
 * The zerocopy_success argument is true if zero copy transmit occurred,
 * false on data copy or out of memory error caused by data copy attempt.
 * The ctx field is used to track device context.
 * The desc field is used to track userspace buffer index.
 */

struct ubuf_info {
	
void (*callback)(struct ubuf_info *, bool zerocopy_success);
	
void *ctx;
	
unsigned long desc;
};

/* This data is invariant across clones and lives at
 * the end of the header data, ie. at skb->end.
 */

struct skb_shared_info {
	
unsigned short	_unused;
	
unsigned char	nr_frags;
	
__u8		tx_flags;
	
unsigned short	gso_size;
	/* Warning: this field is not always filled in (UFO)! */
	
unsigned short	gso_segs;
	
struct sk_buff	*frag_list;
	
struct skb_shared_hwtstamps hwtstamps;
	
unsigned int	gso_type;
	
u32		tskey;
	
__be32          ip6_frag_id;

	/*
         * Warning : all fields before dataref are cleared in __alloc_skb()
         */
	
atomic_t	dataref;

	/* Intermediate layers must ensure that destructor_arg
         * remains valid until skb destructor */
	
void *		destructor_arg;

	/* must be last field, see pskb_expand_head() */
	
skb_frag_t	frags[MAX_SKB_FRAGS];
};

/* We divide dataref into two halves.  The higher 16 bits hold references
 * to the payload part of skb->data.  The lower 16 bits hold references to
 * the entire skb->data.  A clone of a headerless skb holds the length of
 * the header in skb->hdr_len.
 *
 * All users must obey the rule that the skb->data reference count must be
 * greater than or equal to the payload reference count.
 *
 * Holding a reference to the payload part means that the user does not
 * care about modifications to the header part of skb->data.
 */

#define SKB_DATAREF_SHIFT 16

#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)


enum {
	
SKB_FCLONE_UNAVAILABLE,	/* skb has no fclone (from head_cache) */
	
SKB_FCLONE_ORIG,	/* orig skb (from fclone_cache) */
	
SKB_FCLONE_CLONE,	/* companion fclone skb (from fclone_cache) */
};

enum {
	
SKB_GSO_TCPV4 = 1 << 0,
	
SKB_GSO_UDP = 1 << 1,

	/* This indicates the skb is from an untrusted source. */
	
SKB_GSO_DODGY = 1 << 2,

	/* This indicates the tcp segment has CWR set. */
	
SKB_GSO_TCP_ECN = 1 << 3,

	
SKB_GSO_TCP_FIXEDID = 1 << 4,

	
SKB_GSO_TCPV6 = 1 << 5,

	
SKB_GSO_FCOE = 1 << 6,

	
SKB_GSO_GRE = 1 << 7,

	
SKB_GSO_GRE_CSUM = 1 << 8,

	
SKB_GSO_IPXIP4 = 1 << 9,

	
SKB_GSO_IPXIP6 = 1 << 10,

	
SKB_GSO_UDP_TUNNEL = 1 << 11,

	
SKB_GSO_UDP_TUNNEL_CSUM = 1 << 12,

	
SKB_GSO_PARTIAL = 1 << 13,

	
SKB_GSO_TUNNEL_REMCSUM = 1 << 14,

	
SKB_GSO_SCTP = 1 << 15,

	
SKB_GSO_ESP = 1 << 16,
};

#if BITS_PER_LONG > 32

#define NET_SKBUFF_DATA_USES_OFFSET 1
#endif

#ifdef NET_SKBUFF_DATA_USES_OFFSET

typedef unsigned int sk_buff_data_t;
#else

typedef unsigned char *sk_buff_data_t;
#endif

/**
 * struct skb_mstamp - multi resolution time stamps
 * @stamp_us: timestamp in us resolution
 * @stamp_jiffies: timestamp in jiffies
 */

struct skb_mstamp {
	union {
		
u64		v64;
		struct {
			
u32	stamp_us;
			
u32	stamp_jiffies;
		};
	};
};

/**
 * skb_mstamp_get - get current timestamp
 * @cl: place to store timestamps
 */



static inline void skb_mstamp_get(struct skb_mstamp *cl)
{
	u64 val = local_clock();

	do_div(val, NSEC_PER_USEC);
	cl->stamp_us = (u32)val;
	cl->stamp_jiffies = (u32)jiffies;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet43100.00%1100.00%


Total43100.00%1100.00%



/**
 * skb_mstamp_delta - compute the difference in usec between two skb_mstamp
 * @t1: pointer to newest sample
 * @t0: pointer to oldest sample
 */



static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
				      const struct skb_mstamp *t0)
{
	s32 delta_us = t1->stamp_us - t0->stamp_us;
	u32 delta_jiffies = t1->stamp_jiffies - t0->stamp_jiffies;

	/* If delta_us is negative, this might be because interval is too big,
         * or local_clock() drift is too big : fallback using jiffies.
         */
	if (delta_us <= 0 ||
	    delta_jiffies >= (INT_MAX / (USEC_PER_SEC / HZ)))

		delta_us = jiffies_to_usecs(delta_jiffies);

	return delta_us;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet70100.00%1100.00%


Total70100.00%1100.00%






static inline bool skb_mstamp_after(const struct skb_mstamp *t1,
				    const struct skb_mstamp *t0)
{
	s32 diff = t1->stamp_jiffies - t0->stamp_jiffies;

	if (!diff)
		diff = t1->stamp_us - t0->stamp_us;
	return diff > 0;
}


Contributors
PersonTokensPropCommitsCommitProp
Yuchung Cheng50100.00%1100.00%


Total50100.00%1100.00%



/** 
 *      struct sk_buff - socket buffer
 *      @next: Next buffer in list
 *      @prev: Previous buffer in list
 *      @tstamp: Time we arrived/left
 *      @rbnode: RB tree node, alternative to next/prev for netem/tcp
 *      @sk: Socket we are owned by
 *      @dev: Device we arrived on/are leaving by
 *      @cb: Control buffer. Free for use by every layer. Put private vars here
 *      @_skb_refdst: destination entry (with norefcount bit)
 *      @sp: the security path, used for xfrm
 *      @len: Length of actual data
 *      @data_len: Data length
 *      @mac_len: Length of link layer header
 *      @hdr_len: writable header length of cloned skb
 *      @csum: Checksum (must include start/offset pair)
 *      @csum_start: Offset from skb->head where checksumming should start
 *      @csum_offset: Offset from csum_start where checksum should be stored
 *      @priority: Packet queueing priority
 *      @ignore_df: allow local fragmentation
 *      @cloned: Head may be cloned (check refcnt to be sure)
 *      @ip_summed: Driver fed us an IP checksum
 *      @nohdr: Payload reference only, must not modify header
 *      @pkt_type: Packet class
 *      @fclone: skbuff clone status
 *      @ipvs_property: skbuff is owned by ipvs
 *      @tc_skip_classify: do not classify packet. set by IFB device
 *      @tc_at_ingress: used within tc_classify to distinguish in/egress
 *      @tc_redirected: packet was redirected by a tc action
 *      @tc_from_ingress: if tc_redirected, tc_at_ingress at time of redirect
 *      @peeked: this packet has been seen already, so stats have been
 *              done for it, don't do them again
 *      @nf_trace: netfilter packet trace flag
 *      @protocol: Packet protocol from driver
 *      @destructor: Destruct function
 *      @_nfct: Associated connection, if any (with nfctinfo bits)
 *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
 *      @skb_iif: ifindex of device we arrived on
 *      @tc_index: Traffic control index
 *      @hash: the packet hash
 *      @queue_mapping: Queue mapping for multiqueue devices
 *      @xmit_more: More SKBs are pending for this queue
 *      @ndisc_nodetype: router type (from link layer)
 *      @ooo_okay: allow the mapping of a socket to a queue to be changed
 *      @l4_hash: indicate hash is a canonical 4-tuple hash over transport
 *              ports.
 *      @sw_hash: indicates hash was computed in software stack
 *      @wifi_acked_valid: wifi_acked was set
 *      @wifi_acked: whether frame was acked on wifi or not
 *      @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
 *      @dst_pending_confirm: need to confirm neighbour
  *     @napi_id: id of the NAPI struct this skb came from
 *      @secmark: security marking
 *      @mark: Generic packet mark
 *      @vlan_proto: vlan encapsulation protocol
 *      @vlan_tci: vlan tag control information
 *      @inner_protocol: Protocol (encapsulation)
 *      @inner_transport_header: Inner transport layer header (encapsulation)
 *      @inner_network_header: Network layer header (encapsulation)
 *      @inner_mac_header: Link layer header (encapsulation)
 *      @transport_header: Transport layer header
 *      @network_header: Network layer header
 *      @mac_header: Link layer header
 *      @tail: Tail pointer
 *      @end: End pointer
 *      @head: Head of buffer
 *      @data: Data head pointer
 *      @truesize: Buffer size
 *      @users: User count - see {datagram,tcp}.c
 */


struct sk_buff {
	union {
		struct {
			/* These two members must be first. */
			
struct sk_buff		*next;
			
struct sk_buff		*prev;

			union {
				
ktime_t		tstamp;
				
struct skb_mstamp skb_mstamp;
			};
		};
		
struct rb_node	rbnode; /* used in netem & tcp stack */
	};
	
struct sock		*sk;

	union {
		
struct net_device	*dev;
		/* Some protocols might use this space to store information,
                 * while device pointer would be NULL.
                 * UDP receive path is one user.
                 */
		
unsigned long		dev_scratch;
	};
	/*
         * This is the control buffer. It is free to use for every
         * layer. Please put your private variables there. If you
         * want to keep them across layers you have to do a skb_clone()
         * first. This is owned by whoever has the skb queued ATM.
         */
	char			cb[48] __aligned(8);

	
unsigned long		_skb_refdst;
	
void			(*destructor)(struct sk_buff *skb);
#ifdef CONFIG_XFRM
	
struct	sec_path	*sp;
#endif
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
	
unsigned long		 _nfct;
#endif
#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
	
struct nf_bridge_info	*nf_bridge;
#endif
	
unsigned int		len,
				
data_len;
	
__u16			mac_len,
				
hdr_len;

	/* Following fields are _not_ copied in __copy_skb_header()
         * Note that queue_mapping is here mostly to fill a hole.
         */
	kmemcheck_bitfield_begin(flags1);
	
__u16			queue_mapping;

/* if you move cloned around you also must adapt those constants */
#ifdef __BIG_ENDIAN_BITFIELD

#define CLONED_MASK	(1 << 7)
#else

#define CLONED_MASK	1
#endif

#define CLONED_OFFSET()		offsetof(struct sk_buff, __cloned_offset)

	
__u8			__cloned_offset[0];
	
__u8			cloned:1,
				
nohdr:1,
				
fclone:2,
				
peeked:1,
				
head_frag:1,
				
xmit_more:1,
				
__unused:1; /* one bit hole */
	kmemcheck_bitfield_end(flags1);

	/* fields enclosed in headers_start/headers_end are copied
         * using a single memcpy() in __copy_skb_header()
         */
	/* private: */
	
__u32			headers_start[0];
	/* public: */

/* if you move pkt_type around you also must adapt those constants */
#ifdef __BIG_ENDIAN_BITFIELD

#define PKT_TYPE_MAX	(7 << 5)
#else

#define PKT_TYPE_MAX	7
#endif

#define PKT_TYPE_OFFSET()	offsetof(struct sk_buff, __pkt_type_offset)

	
__u8			__pkt_type_offset[0];
	
__u8			pkt_type:3;
	
__u8			pfmemalloc:1;
	
__u8			ignore_df:1;

	
__u8			nf_trace:1;
	
__u8			ip_summed:2;
	
__u8			ooo_okay:1;
	
__u8			l4_hash:1;
	
__u8			sw_hash:1;
	
__u8			wifi_acked_valid:1;
	
__u8			wifi_acked:1;

	
__u8			no_fcs:1;
	/* Indicates the inner headers are valid in the skbuff. */
	
__u8			encapsulation:1;
	
__u8			encap_hdr_csum:1;
	
__u8			csum_valid:1;
	
__u8			csum_complete_sw:1;
	
__u8			csum_level:2;
	
__u8			csum_bad:1;

	
__u8			dst_pending_confirm:1;
#ifdef CONFIG_IPV6_NDISC_NODETYPE
	
__u8			ndisc_nodetype:2;
#endif
	
__u8			ipvs_property:1;
	
__u8			inner_protocol_type:1;
	
__u8			remcsum_offload:1;
#ifdef CONFIG_NET_SWITCHDEV
	
__u8			offload_fwd_mark:1;
#endif
#ifdef CONFIG_NET_CLS_ACT
	
__u8			tc_skip_classify:1;
	
__u8			tc_at_ingress:1;
	
__u8			tc_redirected:1;
	
__u8			tc_from_ingress:1;
#endif

#ifdef CONFIG_NET_SCHED
	
__u16			tc_index;	/* traffic control index */
#endif

	union {
		
__wsum		csum;
		struct {
			
__u16	csum_start;
			
__u16	csum_offset;
		};
	};
	
__u32			priority;
	
int			skb_iif;
	
__u32			hash;
	
__be16			vlan_proto;
	
__u16			vlan_tci;
#if defined(CONFIG_NET_RX_BUSY_POLL) || defined(CONFIG_XPS)
	union {
		
unsigned int	napi_id;
		
unsigned int	sender_cpu;
	};
#endif
#ifdef CONFIG_NETWORK_SECMARK
	
__u32		secmark;
#endif

	union {
		
__u32		mark;
		
__u32		reserved_tailroom;
	};

	union {
		
__be16		inner_protocol;
		
__u8		inner_ipproto;
	};

	
__u16			inner_transport_header;
	
__u16			inner_network_header;
	
__u16			inner_mac_header;

	
__be16			protocol;
	
__u16			transport_header;
	
__u16			network_header;
	
__u16			mac_header;

	/* private: */
	
__u32			headers_end[0];
	/* public: */

	/* These elements must be at the end, see alloc_skb() for details.  */
	
sk_buff_data_t		tail;
	
sk_buff_data_t		end;
	
unsigned char		*head,
				
*data;
	
unsigned int		truesize;
	
atomic_t		users;
};

#ifdef __KERNEL__
/*
 *      Handling routines are only of interest to the kernel
 */
#include <linux/slab.h>



#define SKB_ALLOC_FCLONE	0x01

#define SKB_ALLOC_RX		0x02

#define SKB_ALLOC_NAPI		0x04

/* Returns true if the skb was allocated from PFMEMALLOC reserves */



static inline bool skb_pfmemalloc(const struct sk_buff *skb)
{
	return unlikely(skb->pfmemalloc);
}


Contributors
PersonTokensPropCommitsCommitProp
Mel Gorman21100.00%1100.00%


Total21100.00%1100.00%



/*
 * skb might have a dst pointer attached, refcounted or not.
 * _skb_refdst low order bit is set if refcount was _not_ taken
 */

#define SKB_DST_NOREF	1UL

#define SKB_DST_PTRMASK	~(SKB_DST_NOREF)


#define SKB_NFCT_PTRMASK	~(7UL)
/**
 * skb_dst - returns skb dst_entry
 * @skb: buffer
 *
 * Returns skb dst_entry, regardless of reference taken or not.
 */



static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
{
	/* If refdst was not refcounted, check we still are in a 
         * rcu_read_lock section
         */
	WARN_ON((skb->_skb_refdst & SKB_DST_NOREF) &&
		!rcu_read_lock_held() &&
		!rcu_read_lock_bh_held());
	return (struct dst_entry *)(skb->_skb_refdst & SKB_DST_PTRMASK);
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet49100.00%2100.00%


Total49100.00%2100.00%



/**
 * skb_dst_set - sets skb dst
 * @skb: buffer
 * @dst: dst entry
 *
 * Sets skb dst, assuming a reference was taken on dst and should
 * be released by skb_dst_drop()
 */



static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
{
	skb->_skb_refdst = (unsigned long)dst;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet27100.00%2100.00%


Total27100.00%2100.00%



/**
 * skb_dst_set_noref - sets skb dst, hopefully, without taking reference
 * @skb: buffer
 * @dst: dst entry
 *
 * Sets skb dst, assuming a reference was not taken on dst.
 * If dst entry is cached, we do not take reference and dst_release
 * will be avoided by refdst_drop. If dst entry is not cached, we take
 * reference, so that last dst_release can destroy the dst immediately.
 */



static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
{
	WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
	skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
}


Contributors
PersonTokensPropCommitsCommitProp
Julian Anastasov2357.50%150.00%


Hannes Frederic Sowa1742.50%150.00%


Total40100.00%2100.00%



/**
 * skb_dst_is_noref - Test if skb dst isn't refcounted
 * @skb: buffer
 */



static inline bool skb_dst_is_noref(const struct sk_buff *skb)
{
	return (skb->_skb_refdst & SKB_DST_NOREF) && skb_dst(skb);
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet27100.00%1100.00%


Total27100.00%1100.00%






static inline struct rtable *skb_rtable(const struct sk_buff *skb)
{
	return (struct rtable *)skb_dst(skb);
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet26100.00%2100.00%


Total26100.00%2100.00%



/* For mangling skb->pkt_type from user space side from applications
 * such as nft, tc, etc, we only allow a conservative subset of
 * possible pkt_types to be set.
*/



static inline bool skb_pkt_type_ok(u32 ptype)
{
	return ptype <= PACKET_OTHERHOST;
}


Contributors
PersonTokensPropCommitsCommitProp
Jamal Hadi Salim15100.00%1100.00%


Total15100.00%1100.00%



void kfree_skb(struct sk_buff *skb);
void kfree_skb_list(struct sk_buff *segs);
void skb_tx_error(struct sk_buff *skb);
void consume_skb(struct sk_buff *skb);
void  __kfree_skb(struct sk_buff *skb);
extern struct kmem_cache *skbuff_head_cache;

void kfree_skb_partial(struct sk_buff *skb, bool head_stolen);
bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from,
		      bool *fragstolen, int *delta_truesize);

struct sk_buff *__alloc_skb(unsigned int size, gfp_t priority, int flags,
			    int node);
struct sk_buff *__build_skb(void *data, unsigned int frag_size);
struct sk_buff *build_skb(void *data, unsigned int frag_size);



static inline struct sk_buff *alloc_skb(unsigned int size,
					gfp_t priority)
{
	return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
}


Contributors
PersonTokensPropCommitsCommitProp
David S. Miller2589.29%125.00%


Christoph Hellwig13.57%125.00%


Eric Dumazet13.57%125.00%


Al Viro13.57%125.00%


Total28100.00%4100.00%



struct sk_buff *alloc_skb_with_frags(unsigned long header_len,
				     unsigned long data_len,
				     int max_page_order,
				     int *errcode,
				     gfp_t gfp_mask);

/* Layout of fast clones : [skb1][skb2][fclone_ref] */

struct sk_buff_fclones {
	
struct sk_buff	skb1;

	
struct sk_buff	skb2;

	
atomic_t	fclone_ref;
};

/**
 *      skb_fclone_busy - check if fclone is busy
 *      @sk: socket
 *      @skb: buffer
 *
 * Returns true if skb is a fast clone, and its clone is not freed.
 * Some drivers call skb_orphan() in their ndo_start_xmit(),
 * so we also check that this didnt happen.
 */



static inline bool skb_fclone_busy(const struct sock *sk,
				   const struct sk_buff *skb)
{
	const struct sk_buff_fclones *fclones;

	fclones = container_of(skb, struct sk_buff_fclones, skb1);

	return skb->fclone == SKB_FCLONE_ORIG &&
	       atomic_read(&fclones->fclone_ref) > 1 &&
	       fclones->skb2.sk == sk;
}


Contributors
PersonTokensPropCommitsCommitProp
Eric Dumazet62100.00%3100.00%


Total62100.00%3100.00%






static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
					       gfp_t priority)
{
	return __alloc_skb(size, priority, SKB_ALLOC_FCLONE, NUMA_NO_NODE);
}


Contributors
PersonTokensPropCommitsCommitProp
David S. Miller2485.71%120.00%


Mel Gorman13.57%120.00%


Al Viro13.57%120.00%


Eric Dumazet13.57%120.00%


Christoph Hellwig13.57%120.00%


Total28100.00%5100.00%



struct sk_buff *__alloc_skb_head(gfp_t priority, int node);



static inline struct sk_buff *alloc_skb_head(gfp_t priority)
{
	return __alloc_skb_head(priority, -1);
}


Contributors
PersonTokensPropCommitsCommitProp
Patrick McHardy21100.00%1100.00%


Total21100.00%1100.00%



struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t priority);
struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
				   gfp_t gfp_mask, bool fclone);



static inline struct sk_buff *__pskb_copy(struct sk_buff *skb, int headroom,
					  gfp_t gfp_mask)
{
	return __pskb_copy_fclone(skb, headroom, gfp_mask, false);
}


Contributors
PersonTokensPropCommitsCommitProp
Octavian Purdila32100.00%1100.00%


Total32100.00%1100.00%



int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask);
struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
				     unsigned int headroom);
struct sk_buff *skb_copy_expand(const struct sk_buff *skb, int newheadroom,
				int newtailroom, gfp_t priority);
int skb_to_sgvec_nomark(struct sk_buff *skb, struct scatterlist *sg,
			int offset, int len);
int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset,
		 int len);
int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer);
int skb_pad(struct sk_buff *skb, int pad);

#define dev_kfree_skb(a)	consume_skb(a)

int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
			    int getfrag(void *from, char *to, int offset,
					int len, int odd, struct sk_buff *skb),
			    void *from, int length);

int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
			 int offset, size_t size);


struct skb_seq_state {
	
__u32		lower_offset;
	
__u32		upper_offset;
	
__u32		frag_idx;
	
__u32		stepped_offset;
	
struct sk_buff	*root_skb;
	
struct sk_buff	*cur_skb;
	
__u8		*frag_data;
};

void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from,
			  unsigned int to, struct skb_seq_state *st);
unsigned int skb_seq_read(unsigned int consumed, const u8 **data,
			  struct skb_seq_state *st);
void skb_abort_seq_read(struct skb_seq_state *st);

unsigned int skb_find_text(struct sk_buff *skb, unsigned int from,
			   unsigned int to, struct ts_config *config);

/*
 * Packet hash types specify the type of hash in skb_set_hash.
 *
 * Hash types refer to the protocol layer addresses which are used to
 * construct a packet's hash. The hashes are used to differentiate or identify
 * flows of the protocol layer for the hash type. Hash types are either
 * layer-2 (L2), layer-3 (L3), or layer-4 (L4).
 *
 * Properties of hashes:
 *
 * 1) Two packets in different flows have different hash values
 * 2) Two packets in the same flow should have the same hash value
 *
 * A hash at a higher layer is considered to be more specific. A driver should
 * set the most specific hash possible.
 *
 * A driver cannot indicate a more specific hash than the layer at which a hash
 * was computed. For instance an L3 hash cannot be set as an L4 hash.
 *
 * A driver may indicate a hash level which is less specific than the
 * actual layer the hash was computed on. For instance, a hash computed
 * at L4 may be considered an L3 hash. This should only be done if the
 * driver can't unambiguously determine that the HW computed the hash at
 * the higher layer. Note that the "should" in the second property above
 * permits this.
 */

enum pkt_hash_types {
	
PKT_HASH_TYPE_NONE,	/* Undefined type */
	
PKT_HASH_TYPE_L2,	/* Input: src_MAC, dest_MAC */
	
PKT_HASH_TYPE_L3,	/* Input: src_IP, dst_IP */
	
PKT_HASH_TYPE_L4,	/* Input: src_IP, dst_IP, src_port, dst_port */
};




static inline void skb_clear_hash(struct sk_buff *skb)
{
	skb->hash = 0;
	skb->sw_hash = 0;
	skb->l4_hash = 0;
}


Contributors
PersonTokensPropCommitsCommitProp
Tom Herbert30100.00%2100.00%


Total30100.00%2100.00%






static inline void skb_clear_hash_if_not_l4(struct sk_buff *skb)
{
	if (!skb->l4_hash)
		skb_clear_hash(skb);
}


Contributors
PersonTokensPropCommitsCommitProp
Tom Herbert24100.00%1100.00%


Total24100.00%1100.00%





static inline void

__skb_set_hash(struct sk_buff *skb, __u32 hash, bool is_sw, bool is_l4)
{
	skb->l4_hash = is_l4;
	skb->sw_hash = is_sw;
	skb->hash = hash;
}


Contributors
PersonTokensPropCommitsCommitProp
Tom Herbert39100.00%4100.00%


Total39100.00%4100.00%





static inline void

skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
{
	/* Used by drivers to set hash from HW */
	__skb_set_hash(skb, hash, false, type == PKT_HASH_TYPE_L4