Linux Networking and Network Devices APIs¶

Linux Networking¶

Networking Base Types¶

enum sock_type: Socket types

Constants

SOCK_STREAM: stream (connection) socket
SOCK_DGRAM: datagram (conn.less) socket
SOCK_RAW: raw socket
SOCK_RDM: reliably-delivered message
SOCK_SEQPACKET: sequential packet socket
SOCK_DCCP: Datagram Congestion Control Protocol socket
SOCK_PACKET: linux specific way of getting packets at the dev level. For writing rarp and other similar things on the user level.

Description

When adding some new socket type please grep ARCH_HAS_SOCKET_TYPE include/asm-* /socket.h, at least MIPS overrides this enum for binary compat reasons.

enum sock_shutdown_cmd: Shutdown types

Constants

SHUT_RD: shutdown receptions
SHUT_WR: shutdown transmissions
SHUT_RDWR: shutdown receptions/transmissions

struct socket: general BSD socket

Definition

struct socket {
  socket_state state;
  short type;
  unsigned long           flags;
  struct file             *file;
  struct sock             *sk;
  const struct proto_ops  *ops;
  struct socket_wq        wq;
};

Members

state: socket state (SS_CONNECTED, etc)
type: socket type (SOCK_STREAM, etc)
flags: socket flags (SOCK_NOSPACE, etc)
file: File back pointer for gc
sk: internal networking protocol agnostic socket representation
ops: protocol specific socket operations
wq: wait queue for several uses

Socket Buffer Functions¶

unsigned int skb_frag_size(const skb_frag_t *frag)¶: Returns the size of a skb fragment

Parameters

const skb_frag_t * frag: skb fragment

void skb_frag_size_set(skb_frag_t *frag, unsigned int size)¶: Sets the size of a skb fragment

Parameters

skb_frag_t * frag: skb fragment
unsigned int size: size of fragment

void skb_frag_size_add(skb_frag_t *frag, int delta)¶: Increments the size of a skb fragment by delta

Parameters

skb_frag_t * frag: skb fragment
int delta: value to add

void skb_frag_size_sub(skb_frag_t *frag, int delta)¶: Decrements the size of a skb fragment by delta

Parameters

skb_frag_t * frag: skb fragment
int delta: value to subtract

bool skb_frag_must_loop(struct page *p)¶: Test if p is a high memory page

Parameters

struct page * p: fragment’s page

skb_frag_foreach_page ( f, f_off, f_len, p, p_off, p_len, copied): loop over pages in a fragment

Parameters

f: skb frag to operate on
f_off: offset from start of f->bv_page
f_len: length from f_off to loop over
p: (temp var) current page
p_off: (temp var) offset from start of current page, non-zero only on first page.
p_len: (temp var) length in current page, < PAGE_SIZE only on first and last page.
copied: (temp var) length so far, excluding current p_len.

Description

A fragment can hold a compound page, in which case per-page operations, notably kmap_atomic, must be called for each regular page.

struct skb_shared_hwtstamps: hardware time stamps

Definition

struct skb_shared_hwtstamps {
  ktime_t hwtstamp;
};

Members

hwtstamp: hardware time stamp transformed into duration since arbitrary point in time

Description

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 sk_buff: socket buffer

Definition

struct sk_buff {
  union {
    struct {
      struct sk_buff          *next;
      struct sk_buff          *prev;
      union {
        struct net_device       *dev;
        unsigned long           dev_scratch;
      };
    };
    struct rb_node          rbnode;
    struct list_head        list;
  };
  union {
    struct sock             *sk;
    int ip_defrag_offset;
  };
  union {
    ktime_t tstamp;
    u64 skb_mstamp_ns;
  };
  char cb[48] ;
  union {
    struct {
      unsigned long   _skb_refdst;
      void (*destructor)(struct sk_buff *skb);
    };
    struct list_head        tcp_tsorted_anchor;
  };
#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE);
  unsigned long            _nfct;
#endif;
  unsigned int            len, data_len;
  __u16 mac_len, hdr_len;
  __u16 queue_mapping;
#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:1,nohdr:1,fclone:2,peeked:1,head_frag:1, pfmemalloc:1;
#ifdef CONFIG_SKB_EXTENSIONS;
  __u8 active_extensions;
#endif;
#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:3;
  __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;
  __u8 encapsulation:1;
  __u8 encap_hdr_csum:1;
  __u8 csum_valid:1;
#ifdef __BIG_ENDIAN_BITFIELD;
#define PKT_VLAN_PRESENT_BIT    7;
#else;
#define PKT_VLAN_PRESENT_BIT    0;
#endif;
#define PKT_VLAN_PRESENT_OFFSET()       offsetof(struct sk_buff, __pkt_vlan_present_offset);
  __u8 vlan_present:1;
  __u8 csum_complete_sw:1;
  __u8 csum_level:2;
  __u8 csum_not_inet: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;
  __u8 offload_l3_fwd_mark:1;
#endif;
#ifdef CONFIG_NET_CLS_ACT;
  __u8 tc_skip_classify:1;
  __u8 tc_at_ingress:1;
#endif;
#ifdef CONFIG_NET_REDIRECT;
  __u8 redirected:1;
  __u8 from_ingress:1;
#endif;
#ifdef CONFIG_TLS_DEVICE;
  __u8 decrypted:1;
#endif;
#ifdef CONFIG_NET_SCHED;
  __u16 tc_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;
  sk_buff_data_t tail;
  sk_buff_data_t end;
  unsigned char           *head, *data;
  unsigned int            truesize;
  refcount_t users;
#ifdef CONFIG_SKB_EXTENSIONS;
  struct skb_ext          *extensions;
#endif;
};

Members

{unnamed_union}: anonymous
{unnamed_struct}: anonymous
next: Next buffer in list
prev: Previous buffer in list
{unnamed_union}: anonymous
dev: Device we arrived on/are leaving by
dev_scratch: (aka dev) alternate use of dev when dev would be NULL
rbnode: RB tree node, alternative to next/prev for netem/tcp
list: queue head
{unnamed_union}: anonymous
sk: Socket we are owned by
ip_defrag_offset: (aka sk) alternate use of sk, used in fragmentation management
{unnamed_union}: anonymous
tstamp: Time we arrived/left
skb_mstamp_ns: (aka tstamp) earliest departure time; start point for retransmit timer
cb: Control buffer. Free for use by every layer. Put private vars here
{unnamed_union}: anonymous
{unnamed_struct}: anonymous
_skb_refdst: destination entry (with norefcount bit)
destructor: Destruct function
tcp_tsorted_anchor: list structure for TCP (tp->tsorted_sent_queue)
_nfct: Associated connection, if any (with nfctinfo bits)
len: Length of actual data
data_len: Data length
mac_len: Length of link layer header
hdr_len: writable header length of cloned skb
queue_mapping: Queue mapping for multiqueue devices
cloned: Head may be cloned (check refcnt to be sure)
nohdr: Payload reference only, must not modify header
fclone: skbuff clone status
peeked: this packet has been seen already, so stats have been done for it, don’t do them again
head_frag: skb was allocated from page fragments, not allocated by kmalloc() or vmalloc().
pfmemalloc: skbuff was allocated from PFMEMALLOC reserves
active_extensions: active extensions (skb_ext_id types)
pkt_type: Packet class
ignore_df: allow local fragmentation
nf_trace: netfilter packet trace flag
ip_summed: Driver fed us an IP checksum
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
encapsulation: indicates the inner headers in the skbuff are valid
encap_hdr_csum: software checksum is needed
csum_valid: checksum is already valid
vlan_present: VLAN tag is present
csum_complete_sw: checksum was completed by software
csum_level: indicates the number of consecutive checksums found in the packet minus one that have been verified as CHECKSUM_UNNECESSARY (max 3)
csum_not_inet: use CRC32c to resolve CHECKSUM_PARTIAL
dst_pending_confirm: need to confirm neighbour
ndisc_nodetype: router type (from link layer)
ipvs_property: skbuff is owned by ipvs
inner_protocol_type: whether the inner protocol is ENCAP_TYPE_ETHER or ENCAP_TYPE_IPPROTO
remcsum_offload: remote checksum offload is enabled
offload_fwd_mark: Packet was L2-forwarded in hardware
offload_l3_fwd_mark: Packet was L3-forwarded in hardware
tc_skip_classify: do not classify packet. set by IFB device
tc_at_ingress: used within tc_classify to distinguish in/egress
redirected: packet was redirected by packet classifier
from_ingress: packet was redirected from the ingress path
decrypted: Decrypted SKB
tc_index: Traffic control index
{unnamed_union}: anonymous
csum: Checksum (must include start/offset pair)
{unnamed_struct}: anonymous
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
skb_iif: ifindex of device we arrived on
hash: the packet hash
vlan_proto: vlan encapsulation protocol
vlan_tci: vlan tag control information
{unnamed_union}: anonymous
napi_id: id of the NAPI struct this skb came from
sender_cpu: (aka napi_id) source CPU in XPS
secmark: security marking
{unnamed_union}: anonymous
mark: Generic packet mark
reserved_tailroom: (aka mark) number of bytes of free space available at the tail of an sk_buff
{unnamed_union}: anonymous
inner_protocol: Protocol (encapsulation)
inner_ipproto: (aka inner_protocol) stores ipproto when skb->inner_protocol_type == ENCAP_TYPE_IPPROTO;
inner_transport_header: Inner transport layer header (encapsulation)
inner_network_header: Network layer header (encapsulation)
inner_mac_header: Link layer header (encapsulation)
protocol: Packet protocol from driver
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
extensions: allocated extensions, valid if active_extensions is nonzero

bool skb_pfmemalloc(const struct sk_buff *skb)¶: Test if the skb was allocated from PFMEMALLOC reserves

Parameters

const struct sk_buff * skb: buffer

struct dst_entry *skb_dst(const struct sk_buff *skb)¶: returns skb dst_entry

Parameters

const struct sk_buff * skb: buffer

Description

Returns skb dst_entry, regardless of reference taken or not.

void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)¶: sets skb dst

Parameters

struct sk_buff * skb: buffer
struct dst_entry * dst: dst entry

Description

Sets skb dst, assuming a reference was taken on dst and should be released by skb_dst_drop()

void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)¶: sets skb dst, hopefully, without taking reference

Parameters

struct sk_buff * skb: buffer
struct dst_entry * dst: dst entry

Description

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.

bool skb_dst_is_noref(const struct sk_buff *skb)¶: Test if skb dst isn’t refcounted

Parameters

const struct sk_buff * skb: buffer

struct rtable *skb_rtable(const struct sk_buff *skb)¶: Returns the skb rtable

Parameters

const struct sk_buff * skb: buffer

unsigned int skb_napi_id(const struct sk_buff *skb)¶: Returns the skb’s NAPI id

Parameters

const struct sk_buff * skb: buffer

bool skb_unref(struct sk_buff *skb)¶: decrement the skb’s reference count

Parameters

struct sk_buff * skb: buffer

Description

Returns true if we can free the skb.

struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)¶: allocate a network buffer

Parameters

unsigned int size: size to allocate
gfp_t priority: allocation mask

Description

This function is a convenient wrapper around __alloc_skb().

bool skb_fclone_busy(const struct sock *sk, const struct sk_buff *skb)¶: check if fclone is busy

Parameters

const struct sock * sk: socket
const struct sk_buff * skb: buffer

Description

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.

struct sk_buff *alloc_skb_fclone(unsigned int size, gfp_t priority)¶: allocate a network buffer from fclone cache

Parameters

unsigned int size: size to allocate
gfp_t priority: allocation mask

Description

This function is a convenient wrapper around __alloc_skb().

int skb_pad(struct sk_buff *skb, int pad)¶: zero pad the tail of an skb

Parameters

struct sk_buff * skb: buffer to pad
int pad: space to pad

Description

Ensure that a buffer is followed by a padding area that is zero filled. Used by network drivers which may DMA or transfer data beyond the buffer end onto the wire.

May return error in out of memory cases. The skb is freed on error.

int skb_queue_empty(const struct sk_buff_head *list)¶: check if a queue is empty

Parameters

const struct sk_buff_head * list: queue head

Description

Returns true if the queue is empty, false otherwise.

bool skb_queue_empty_lockless(const struct sk_buff_head *list)¶: check if a queue is empty

Parameters

const struct sk_buff_head * list: queue head

Description

Returns true if the queue is empty, false otherwise. This variant can be used in lockless contexts.

bool skb_queue_is_last(const struct sk_buff_head *list, const struct sk_buff *skb)¶: check if skb is the last entry in the queue

Parameters

const struct sk_buff_head * list: queue head
const struct sk_buff * skb: buffer

Description

Returns true if skb is the last buffer on the list.

bool skb_queue_is_first(const struct sk_buff_head *list, const struct sk_buff *skb)¶: check if skb is the first entry in the queue

Parameters

const struct sk_buff_head * list: queue head
const struct sk_buff * skb: buffer

Description

Returns true if skb is the first buffer on the list.

struct sk_buff *skb_queue_next(const struct sk_buff_head *list, const struct sk_buff *skb)¶: return the next packet in the queue

Parameters

const struct sk_buff_head * list: queue head
const struct sk_buff * skb: current buffer

Description

Return the next packet in list after skb. It is only valid to call this if skb_queue_is_last() evaluates to false.

struct sk_buff *skb_queue_prev(const struct sk_buff_head *list, const struct sk_buff *skb)¶: return the prev packet in the queue

Parameters

const struct sk_buff_head * list: queue head
const struct sk_buff * skb: current buffer

Description

Return the prev packet in list before skb. It is only valid to call this if skb_queue_is_first() evaluates to false.

struct sk_buff *skb_get(struct sk_buff *skb)¶: reference buffer

Parameters

struct sk_buff * skb: buffer to reference

Description

Makes another reference to a socket buffer and returns a pointer to the buffer.

int skb_cloned(const struct sk_buff *skb)¶: is the buffer a clone

Parameters

const struct sk_buff * skb: buffer to check

Description

Returns true if the buffer was generated with skb_clone() and is one of multiple shared copies of the buffer. Cloned buffers are shared data so must not be written to under normal circumstances.

int skb_header_cloned(const struct sk_buff *skb)¶: is the header a clone

Parameters

const struct sk_buff * skb: buffer to check

Description

Returns true if modifying the header part of the buffer requires the data to be copied.

void __skb_header_release(struct sk_buff *skb)¶: release reference to header

Parameters

struct sk_buff * skb: buffer to operate on

int skb_shared(const struct sk_buff *skb)¶: is the buffer shared

Parameters

const struct sk_buff * skb: buffer to check

Description

Returns true if more than one person has a reference to this buffer.

struct sk_buff *skb_share_check(struct sk_buff *skb, gfp_t pri)¶: check if buffer is shared and if so clone it

Parameters

struct sk_buff * skb: buffer to check
gfp_t pri: priority for memory allocation

Description

If the buffer is shared the buffer is cloned and the old copy drops a reference. A new clone with a single reference is returned. If the buffer is not shared the original buffer is returned. When being called from interrupt status or with spinlocks held pri must be GFP_ATOMIC.

NULL is returned on a memory allocation failure.

struct sk_buff *skb_unshare(struct sk_buff *skb, gfp_t pri)¶: make a copy of a shared buffer

Parameters

struct sk_buff * skb: buffer to check
gfp_t pri: priority for memory allocation

Description

If the socket buffer is a clone then this function creates a new copy of the data, drops a reference count on the old copy and returns the new copy with the reference count at 1. If the buffer is not a clone the original buffer is returned. When called with a spinlock held or from interrupt state pri must be GFP_ATOMIC

NULL is returned on a memory allocation failure.

struct sk_buff *skb_peek(const struct sk_buff_head *list_)¶: peek at the head of an sk_buff_head

Parameters

const struct sk_buff_head * list_: list to peek at

Description

Peek an sk_buff. Unlike most other operations you _MUST_ be careful with this one. A peek leaves the buffer on the list and someone else may run off with it. You must hold the appropriate locks or have a private queue to do this.

Returns NULL for an empty list or a pointer to the head element. The reference count is not incremented and the reference is therefore volatile. Use with caution.

struct sk_buff *__skb_peek(const struct sk_buff_head *list_)¶: peek at the head of a non-empty sk_buff_head

Parameters

const struct sk_buff_head * list_: list to peek at

Description

Like skb_peek(), but the caller knows that the list is not empty.

struct sk_buff *skb_peek_next(struct sk_buff *skb, const struct sk_buff_head *list_)¶: peek skb following the given one from a queue

Parameters

struct sk_buff * skb: skb to start from
const struct sk_buff_head * list_: list to peek at

Description

Returns NULL when the end of the list is met or a pointer to the next element. The reference count is not incremented and the reference is therefore volatile. Use with caution.

struct sk_buff *skb_peek_tail(const struct sk_buff_head *list_)¶: peek at the tail of an sk_buff_head

Parameters

const struct sk_buff_head * list_: list to peek at

Description

Peek an sk_buff. Unlike most other operations you _MUST_ be careful with this one. A peek leaves the buffer on the list and someone else may run off with it. You must hold the appropriate locks or have a private queue to do this.

Returns NULL for an empty list or a pointer to the tail element. The reference count is not incremented and the reference is therefore volatile. Use with caution.

__u32 skb_queue_len(const struct sk_buff_head *list_)¶: get queue length

Parameters

const struct sk_buff_head * list_: list to measure

Description

Return the length of an sk_buff queue.

__u32 skb_queue_len_lockless(const struct sk_buff_head *list_)¶: get queue length

Parameters

const struct sk_buff_head * list_: list to measure

Description

Return the length of an sk_buff queue. This variant can be used in lockless contexts.

void __skb_queue_head_init(struct sk_buff_head *list)¶: initialize non-spinlock portions of sk_buff_head

Parameters

struct sk_buff_head * list: queue to initialize

Description

This initializes only the list and queue length aspects of an sk_buff_head object. This allows to initialize the list aspects of an sk_buff_head without reinitializing things like the spinlock. It can also be used for on-stack sk_buff_head objects where the spinlock is known to not be used.

void skb_queue_splice(const struct sk_buff_head *list, struct sk_buff_head *head)¶: join two skb lists, this is designed for stacks

Parameters

const struct sk_buff_head * list: the new list to add
struct sk_buff_head * head: the place to add it in the first list

void skb_queue_splice_init(struct sk_buff_head *list, struct sk_buff_head *head)¶: join two skb lists and reinitialise the emptied list

Parameters

struct sk_buff_head * list: the new list to add
struct sk_buff_head * head: the place to add it in the first list

Description

The list at list is reinitialised

void skb_queue_splice_tail(const struct sk_buff_head *list, struct sk_buff_head *head)¶: join two skb lists, each list being a queue

Parameters

const struct sk_buff_head * list: the new list to add
struct sk_buff_head * head: the place to add it in the first list

void skb_queue_splice_tail_init(struct sk_buff_head *list, struct sk_buff_head *head)¶: join two skb lists and reinitialise the emptied list

Parameters

struct sk_buff_head * list: the new list to add
struct sk_buff_head * head: the place to add it in the first list

Description

Each of the lists is a queue. The list at list is reinitialised

void __skb_queue_after(struct sk_buff_head *list, struct sk_buff *prev, struct sk_buff *newsk)¶: queue a buffer at the list head

Parameters

struct sk_buff_head * list: list to use
struct sk_buff * prev: place after this buffer
struct sk_buff * newsk: buffer to queue

Description

Queue a buffer int the middle of a list. This function takes no locks and you must therefore hold required locks before calling it.

A buffer cannot be placed on two lists at the same time.

void __skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)¶: queue a buffer at the list head

Parameters

struct sk_buff_head * list: list to use
struct sk_buff * newsk: buffer to queue

Description

Queue a buffer at the start of a list. This function takes no locks and you must therefore hold required locks before calling it.

A buffer cannot be placed on two lists at the same time.

void __skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)¶: queue a buffer at the list tail

Parameters

struct sk_buff_head * list: list to use
struct sk_buff * newsk: buffer to queue

Description

Queue a buffer at the end of a list. This function takes no locks and you must therefore hold required locks before calling it.

A buffer cannot be placed on two lists at the same time.

struct sk_buff *__skb_dequeue(struct sk_buff_head *list)¶: remove from the head of the queue

Parameters

struct sk_buff_head * list: list to dequeue from

Description

Remove the head of the list. This function does not take any locks so must be used with appropriate locks held only. The head item is returned or NULL if the list is empty.

struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)¶: remove from the tail of the queue

Parameters

struct sk_buff_head * list: list to dequeue from

Description

Remove the tail of the list. This function does not take any locks so must be used with appropriate locks held only. The tail item is returned or NULL if the list is empty.

void __skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size)¶: initialise a paged fragment in an skb

Parameters

struct sk_buff * skb: buffer containing fragment to be initialised
int i: paged fragment index to initialise
struct page * page: the page to use for this fragment
int off: the offset to the data with page
int size: the length of the data

Description

Initialises the i’th fragment of skb to point to size bytes at offset off within page.

Does not take any additional reference on the fragment.

void skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size)¶: initialise a paged fragment in an skb

Parameters

struct sk_buff * skb: buffer containing fragment to be initialised
int i: paged fragment index to initialise
struct page * page: the page to use for this fragment
int off: the offset to the data with page
int size: the length of the data

Description

As per __skb_fill_page_desc() – initialises the i’th fragment of skb to point to size bytes at offset off within page. In addition updates skb such that i is the last fragment.

Does not take any additional reference on the fragment.

unsigned int skb_headroom(const struct sk_buff *skb)¶: bytes at buffer head

Parameters

const struct sk_buff * skb: buffer to check

Description

Return the number of bytes of free space at the head of an sk_buff.

int skb_tailroom(const struct sk_buff *skb)¶: bytes at buffer end

Parameters

const struct sk_buff * skb: buffer to check

Description

Return the number of bytes of free space at the tail of an sk_buff

int skb_availroom(const struct sk_buff *skb)¶: bytes at buffer end

Parameters

const struct sk_buff * skb: buffer to check

Description

Return the number of bytes of free space at the tail of an sk_buff allocated by sk_stream_alloc()

void skb_reserve(struct sk_buff *skb, int len)¶: adjust headroom

Parameters

struct sk_buff * skb: buffer to alter
int len: bytes to move

Description

Increase the headroom of an empty sk_buff by reducing the tail room. This is only allowed for an empty buffer.

void skb_tailroom_reserve(struct sk_buff *skb, unsigned int mtu, unsigned int needed_tailroom)¶: adjust reserved_tailroom

Parameters

struct sk_buff * skb: buffer to alter
unsigned int mtu: maximum amount of headlen permitted
unsigned int needed_tailroom: minimum amount of reserved_tailroom

Description

Set reserved_tailroom so that headlen can be as large as possible but not larger than mtu and tailroom cannot be smaller than needed_tailroom. The required headroom should already have been reserved before using this function.

void pskb_trim_unique(struct sk_buff *skb, unsigned int len)¶: remove end from a paged unique (not cloned) buffer

Parameters

struct sk_buff * skb: buffer to alter
unsigned int len: new length

Description

This is identical to pskb_trim except that the caller knows that the skb is not cloned so we should never get an error due to out- of-memory.

void skb_orphan(struct sk_buff *skb)¶: orphan a buffer

Parameters

struct sk_buff * skb: buffer to orphan

Description

If a buffer currently has an owner then we call the owner’s destructor function and make the skb unowned. The buffer continues to exist but is no longer charged to its former owner.

int skb_orphan_frags(struct sk_buff *skb, gfp_t gfp_mask)¶: orphan the frags contained in a buffer

Parameters

struct sk_buff * skb: buffer to orphan frags from
gfp_t gfp_mask: allocation mask for replacement pages

Description

For each frag in the SKB which needs a destructor (i.e. has an owner) create a copy of that frag and release the original page by calling the destructor.

void __skb_queue_purge(struct sk_buff_head *list)¶: empty a list

Parameters

struct sk_buff_head * list: list to empty

Description

Delete all buffers on an sk_buff list. Each buffer is removed from the list and one reference dropped. This function does not take the list lock and the caller must hold the relevant locks to use it.

struct sk_buff *netdev_alloc_skb(struct net_device *dev, unsigned int length)¶: allocate an skbuff for rx on a specific device

Parameters

struct net_device * dev: network device to receive on
unsigned int length: length to allocate

Description

Allocate a new sk_buff and assign it a usage count of one. The buffer has unspecified headroom built in. Users should allocate the headroom they think they need without accounting for the built in space. The built in space is used for optimisations.

NULL is returned if there is no free memory. Although this function allocates memory it can be called from an interrupt.

struct page *__dev_alloc_pages(gfp_t gfp_mask, unsigned int order)¶: allocate page for network Rx

Parameters

gfp_t gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx
unsigned int order: size of the allocation

Description

Allocate a new page.

NULL is returned if there is no free memory.

struct page *__dev_alloc_page(gfp_t gfp_mask)¶: allocate a page for network Rx

Parameters

gfp_t gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx

Description

Allocate a new page.

NULL is returned if there is no free memory.

void skb_propagate_pfmemalloc(struct page *page, struct sk_buff *skb)¶: Propagate pfmemalloc if skb is allocated after RX page

Parameters

struct page * page: The page that was allocated from skb_alloc_page
struct sk_buff * skb: The skb that may need pfmemalloc set

unsigned int skb_frag_off(const skb_frag_t *frag)¶: Returns the offset of a skb fragment

Parameters

const skb_frag_t * frag: the paged fragment

void skb_frag_off_add(skb_frag_t *frag, int delta)¶: Increments the offset of a skb fragment by delta

Parameters

skb_frag_t * frag: skb fragment
int delta: value to add

void skb_frag_off_set(skb_frag_t *frag, unsigned int offset)¶: Sets the offset of a skb fragment

Parameters

skb_frag_t * frag: skb fragment
unsigned int offset: offset of fragment

void skb_frag_off_copy(skb_frag_t *fragto, const skb_frag_t *fragfrom)¶: Sets the offset of a skb fragment from another fragment

Parameters

skb_frag_t * fragto: skb fragment where offset is set
const skb_frag_t * fragfrom: skb fragment offset is copied from

struct page *skb_frag_page(const skb_frag_t *frag)¶: retrieve the page referred to by a paged fragment

Parameters

const skb_frag_t * frag: the paged fragment

Description

Returns the struct page associated with frag.

void __skb_frag_ref(skb_frag_t *frag)¶: take an addition reference on a paged fragment.

Parameters

skb_frag_t * frag: the paged fragment

Description

Takes an additional reference on the paged fragment frag.

void skb_frag_ref(struct sk_buff *skb, int f)¶: take an addition reference on a paged fragment of an skb.

Parameters

struct sk_buff * skb: the buffer
int f: the fragment offset.

Description

Takes an additional reference on the f’th paged fragment of skb.

void __skb_frag_unref(skb_frag_t *frag)¶: release a reference on a paged fragment.

Parameters

skb_frag_t * frag: the paged fragment

Description

Releases a reference on the paged fragment frag.

void skb_frag_unref(struct sk_buff *skb, int f)¶: release a reference on a paged fragment of an skb.

Parameters

struct sk_buff * skb: the buffer
int f: the fragment offset

Description

Releases a reference on the f’th paged fragment of skb.

void *skb_frag_address(const skb_frag_t *frag)¶: gets the address of the data contained in a paged fragment

Parameters

const skb_frag_t * frag: the paged fragment buffer

Description

Returns the address of the data within frag. The page must already be mapped.

void *skb_frag_address_safe(const skb_frag_t *frag)¶: gets the address of the data contained in a paged fragment

Parameters

const skb_frag_t * frag: the paged fragment buffer

Description

Returns the address of the data within frag. Checks that the page is mapped and returns NULL otherwise.

void skb_frag_page_copy(skb_frag_t *fragto, const skb_frag_t *fragfrom)¶: sets the page in a fragment from another fragment

Parameters

skb_frag_t * fragto: skb fragment where page is set
const skb_frag_t * fragfrom: skb fragment page is copied from

void __skb_frag_set_page(skb_frag_t *frag, struct page *page)¶: sets the page contained in a paged fragment

Parameters

skb_frag_t * frag: the paged fragment
struct page * page: the page to set

Description

Sets the fragment frag to contain page.

void skb_frag_set_page(struct sk_buff *skb, int f, struct page *page)¶: sets the page contained in a paged fragment of an skb

Parameters

struct sk_buff * skb: the buffer
int f: the fragment offset
struct page * page: the page to set

Description

Sets the f’th fragment of skb to contain page.

dma_addr_t skb_frag_dma_map(struct device *dev, const skb_frag_t *frag, size_t offset, size_t size, enum dma_data_direction dir)¶: maps a paged fragment via the DMA API

Parameters

struct device * dev: the device to map the fragment to
const skb_frag_t * frag: the paged fragment to map
size_t offset: the offset within the fragment (starting at the fragment’s own offset)
size_t size: the number of bytes to map
enum dma_data_direction dir: the direction of the mapping (PCI_DMA_*)

Description

Maps the page associated with frag to device.

int skb_clone_writable(const struct sk_buff *skb, unsigned int len)¶: is the header of a clone writable

Parameters

const struct sk_buff * skb: buffer to check
unsigned int len: length up to which to write

Description

Returns true if modifying the header part of the cloned buffer does not requires the data to be copied.

int skb_cow(struct sk_buff *skb, unsigned int headroom)¶: copy header of skb when it is required

Parameters

struct sk_buff * skb: buffer to cow
unsigned int headroom: needed headroom

Description

If the skb passed lacks sufficient headroom or its data part is shared, data is reallocated. If reallocation fails, an error is returned and original skb is not changed.

The result is skb with writable area skb->head…skb->tail and at least headroom of space at head.

int skb_cow_head(struct sk_buff *skb, unsigned int headroom)¶: skb_cow but only making the head writable

Parameters

struct sk_buff * skb: buffer to cow
unsigned int headroom: needed headroom

Description

This function is identical to skb_cow except that we replace the skb_cloned check by skb_header_cloned. It should be used when you only need to push on some header and do not need to modify the data.

int skb_padto(struct sk_buff *skb, unsigned int len)¶: pad an skbuff up to a minimal size

Parameters

struct sk_buff * skb: buffer to pad
unsigned int len: minimal length

Description

Pads up a buffer to ensure the trailing bytes exist and are blanked. If the buffer already contains sufficient data it is untouched. Otherwise it is extended. Returns zero on success. The skb is freed on error.

int __skb_put_padto(struct sk_buff *skb, unsigned int len, bool free_on_error)¶: increase size and pad an skbuff up to a minimal size

Parameters

struct sk_buff * skb: buffer to pad
unsigned int len: minimal length
bool free_on_error: free buffer on error

Description

Pads up a buffer to ensure the trailing bytes exist and are blanked. If the buffer already contains sufficient data it is untouched. Otherwise it is extended. Returns zero on success. The skb is freed on error if free_on_error is true.

int skb_put_padto(struct sk_buff *skb, unsigned int len)¶: increase size and pad an skbuff up to a minimal size

Parameters

struct sk_buff * skb: buffer to pad
unsigned int len: minimal length

Description

Pads up a buffer to ensure the trailing bytes exist and are blanked. If the buffer already contains sufficient data it is untouched. Otherwise it is extended. Returns zero on success. The skb is freed on error.

int skb_linearize(struct sk_buff *skb)¶: convert paged skb to linear one

Parameters

struct sk_buff * skb: buffer to linarize

Description

If there is no free memory -ENOMEM is returned, otherwise zero is returned and the old skb data released.

bool skb_has_shared_frag(const struct sk_buff *skb)¶: can any frag be overwritten

Parameters

const struct sk_buff * skb: buffer to test

Description

Return true if the skb has at least one frag that might be modified by an external entity (as in vmsplice()/sendfile())

int skb_linearize_cow(struct sk_buff *skb)¶: make sure skb is linear and writable

Parameters

struct sk_buff * skb: buffer to process

Description

If there is no free memory -ENOMEM is returned, otherwise zero is returned and the old skb data released.

void skb_postpull_rcsum(struct sk_buff *skb, const void *start, unsigned int len)¶: update checksum for received skb after pull

Parameters

struct sk_buff * skb: buffer to update
const void * start: start of data before pull
unsigned int len: length of data pulled

Description

After doing a pull on a received packet, you need to call this to update the CHECKSUM_COMPLETE checksum, or set ip_summed to CHECKSUM_NONE so that it can be recomputed from scratch.

void skb_postpush_rcsum(struct sk_buff *skb, const void *start, unsigned int len)¶: update checksum for received skb after push

Parameters

struct sk_buff * skb: buffer to update
const void * start: start of data after push
unsigned int len: length of data pushed

Description

After doing a push on a received packet, you need to call this to update the CHECKSUM_COMPLETE checksum.

void *skb_push_rcsum(struct sk_buff *skb, unsigned int len)¶: push skb and update receive checksum

Parameters

struct sk_buff * skb: buffer to update
unsigned int len: length of data pulled

Description

This function performs an skb_push on the packet and updates the CHECKSUM_COMPLETE checksum. It should be used on receive path processing instead of skb_push unless you know that the checksum difference is zero (e.g., a valid IP header) or you are setting ip_summed to CHECKSUM_NONE.

int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)¶: trim received skb and update checksum

Parameters

struct sk_buff * skb: buffer to trim
unsigned int len: new length

Description

This is exactly the same as pskb_trim except that it ensures the checksum of received packets are still valid after the operation. It can change skb pointers.

bool skb_needs_linearize(struct sk_buff *skb, netdev_features_t features)¶: check if we need to linearize a given skb depending on the given device features.

Parameters

struct sk_buff * skb: socket buffer to check
netdev_features_t features: net device features

Description

Returns true if either: 1. skb has frag_list and the device doesn’t support FRAGLIST, or 2. skb is fragmented and the device does not support SG.

void skb_get_timestamp(const struct sk_buff *skb, struct __kernel_old_timeval *stamp)¶: get timestamp from a skb

Parameters

const struct sk_buff * skb: skb to get stamp from
struct __kernel_old_timeval * stamp: pointer to struct __kernel_old_timeval to store stamp in

Description

Timestamps are stored in the skb as offsets to a base timestamp. This function converts the offset back to a struct timeval and stores it in stamp.

void skb_complete_tx_timestamp(struct sk_buff *skb, struct skb_shared_hwtstamps *hwtstamps)¶: deliver cloned skb with tx timestamps

Parameters

struct sk_buff * skb: clone of the the original outgoing packet
struct skb_shared_hwtstamps * hwtstamps: hardware time stamps

Description

PHY drivers may accept clones of transmitted packets for timestamping via their phy_driver.txtstamp method. These drivers must call this function to return the skb back to the stack with a timestamp.

void skb_tstamp_tx(struct sk_buff *orig_skb, struct skb_shared_hwtstamps *hwtstamps)¶: queue clone of skb with send time stamps

Parameters

struct sk_buff * orig_skb: the original outgoing packet
struct skb_shared_hwtstamps * hwtstamps: hardware time stamps, may be NULL if not available

Description

If the skb has a socket associated, then this function clones the skb (thus sharing the actual data and optional structures), stores the optional hardware time stamping information (if non NULL) or generates a software time stamp (otherwise), then queues the clone to the error queue of the socket. Errors are silently ignored.

void skb_tx_timestamp(struct sk_buff *skb)¶: Driver hook for transmit timestamping

Parameters

struct sk_buff * skb: A socket buffer.

Description

Ethernet MAC Drivers should call this function in their hard_xmit() function immediately before giving the sk_buff to the MAC hardware.

Specifically, one should make absolutely sure that this function is called before TX completion of this packet can trigger. Otherwise the packet could potentially already be freed.

void skb_complete_wifi_ack(struct sk_buff *skb, bool acked)¶: deliver skb with wifi status

Parameters

struct sk_buff * skb: the original outgoing packet
bool acked: ack status

__sum16 skb_checksum_complete(struct sk_buff *skb)¶: Calculate checksum of an entire packet

Parameters

struct sk_buff * skb: packet to process

Description

This function calculates the checksum over the entire packet plus the value of skb->csum. The latter can be used to supply the checksum of a pseudo header as used by TCP/UDP. It returns the checksum.

For protocols that contain complete checksums such as ICMP/TCP/UDP, this function can be used to verify that checksum on received packets. In that case the function should return zero if the checksum is correct. In particular, this function will return zero if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the hardware has already verified the correctness of the checksum.

struct skb_ext: sk_buff extensions

Definition

struct skb_ext {
  refcount_t refcnt;
  u8 offset[SKB_EXT_NUM];
  u8 chunks;
  char data[] ;
};

Members

refcnt: 1 on allocation, deallocated on 0
offset: offset to add to data to obtain extension address
chunks: size currently allocated, stored in SKB_EXT_ALIGN_SHIFT units
data: start of extension data, variable sized

Note

offsets/lengths are stored in chunks of 8 bytes, this allows: to use ‘u8’ types while allowing up to 2kb worth of extension data.

void skb_checksum_none_assert(const struct sk_buff *skb)¶: make sure skb ip_summed is CHECKSUM_NONE

Parameters

const struct sk_buff * skb: skb to check

Description

fresh skbs have their ip_summed set to CHECKSUM_NONE. Instead of forcing ip_summed to CHECKSUM_NONE, we can use this helper, to document places where we make this assertion.

bool skb_head_is_locked(const struct sk_buff *skb)¶: Determine if the skb->head is locked down

Parameters

const struct sk_buff * skb: skb to check

Description

The head on skbs build around a head frag can be removed if they are not cloned. This function returns true if the skb head is locked down due to either being allocated via kmalloc, or by being a clone with multiple references to the head.

struct sock_common: minimal network layer representation of sockets

Definition

struct sock_common {
  union {
    __addrpair skc_addrpair;
    struct {
      __be32 skc_daddr;
      __be32 skc_rcv_saddr;
    };
  };
  union {
    unsigned int    skc_hash;
    __u16 skc_u16hashes[2];
  };
  union {
    __portpair skc_portpair;
    struct {
      __be16 skc_dport;
      __u16 skc_num;
    };
  };
  unsigned short          skc_family;
  volatile unsigned char  skc_state;
  unsigned char           skc_reuse:4;
  unsigned char           skc_reuseport:1;
  unsigned char           skc_ipv6only:1;
  unsigned char           skc_net_refcnt:1;
  int skc_bound_dev_if;
  union {
    struct hlist_node       skc_bind_node;
    struct hlist_node       skc_portaddr_node;
  };
  struct proto            *skc_prot;
  possible_net_t skc_net;
#if IS_ENABLED(CONFIG_IPV6);
  struct in6_addr         skc_v6_daddr;
  struct in6_addr         skc_v6_rcv_saddr;
#endif;
  atomic64_t skc_cookie;
  union {
    unsigned long   skc_flags;
    struct sock     *skc_listener;
    struct inet_timewait_death_row *skc_tw_dr;
  };
  union {
    struct hlist_node       skc_node;
    struct hlist_nulls_node skc_nulls_node;
  };
  unsigned short          skc_tx_queue_mapping;
#ifdef CONFIG_XPS;
  unsigned short          skc_rx_queue_mapping;
#endif;
  union {
    int skc_incoming_cpu;
    u32 skc_rcv_wnd;
    u32 skc_tw_rcv_nxt;
  };
  refcount_t skc_refcnt;
};

Members

{unnamed_union}: anonymous
skc_addrpair: 8-byte-aligned __u64 union of skc_daddr & skc_rcv_saddr
{unnamed_struct}: anonymous
skc_daddr: Foreign IPv4 addr
skc_rcv_saddr: Bound local IPv4 addr
{unnamed_union}: anonymous
skc_hash: hash value used with various protocol lookup tables
skc_u16hashes: two u16 hash values used by UDP lookup tables
{unnamed_union}: anonymous
skc_portpair: __u32 union of skc_dport & skc_num
{unnamed_struct}: anonymous
skc_dport: placeholder for inet_dport/tw_dport
skc_num: placeholder for inet_num/tw_num
skc_family: network address family
skc_state: Connection state
skc_reuse: SO_REUSEADDR setting
skc_reuseport: SO_REUSEPORT setting
skc_ipv6only: socket is IPV6 only
skc_net_refcnt: socket is using net ref counting
skc_bound_dev_if: bound device index if != 0
{unnamed_union}: anonymous
skc_bind_node: bind hash linkage for various protocol lookup tables
skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
skc_prot: protocol handlers inside a network family
skc_net: reference to the network namespace of this socket
skc_v6_daddr: IPV6 destination address
skc_v6_rcv_saddr: IPV6 source address
skc_cookie: socket’s cookie value
{unnamed_union}: anonymous
skc_flags: place holder for sk_flags SO_LINGER (l_onoff), SO_BROADCAST, SO_KEEPALIVE, SO_OOBINLINE settings, SO_TIMESTAMPING settings
skc_listener: connection request listener socket (aka rsk_listener) [union with skc_flags]
skc_tw_dr: (aka tw_dr) ptr to struct inet_timewait_death_row [union with skc_flags]
{unnamed_union}: anonymous
skc_node: main hash linkage for various protocol lookup tables
skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
skc_tx_queue_mapping: tx queue number for this connection
skc_rx_queue_mapping: rx queue number for this connection
{unnamed_union}: anonymous
skc_incoming_cpu: record/match cpu processing incoming packets
skc_rcv_wnd: (aka rsk_rcv_wnd) TCP receive window size (possibly scaled) [union with skc_incoming_cpu]
skc_tw_rcv_nxt: (aka tw_rcv_nxt) TCP window next expected seq number [union with skc_incoming_cpu]
skc_refcnt: reference count

Description

This is the minimal network layer representation of sockets, the header for struct sock and struct inet_timewait_sock.

struct sock: network layer representation of sockets

Definition

struct sock {
  struct sock_common      __sk_common;
#define sk_node                 __sk_common.skc_node;
#define sk_nulls_node           __sk_common.skc_nulls_node;
#define sk_refcnt               __sk_common.skc_refcnt;
#define sk_tx_queue_mapping     __sk_common.skc_tx_queue_mapping;
#ifdef CONFIG_XPS;
#define sk_rx_queue_mapping     __sk_common.skc_rx_queue_mapping;
#endif;
#define sk_dontcopy_begin       __sk_common.skc_dontcopy_begin;
#define sk_dontcopy_end         __sk_common.skc_dontcopy_end;
#define sk_hash                 __sk_common.skc_hash;
#define sk_portpair             __sk_common.skc_portpair;
#define sk_num                  __sk_common.skc_num;
#define sk_dport                __sk_common.skc_dport;
#define sk_addrpair             __sk_common.skc_addrpair;
#define sk_daddr                __sk_common.skc_daddr;
#define sk_rcv_saddr            __sk_common.skc_rcv_saddr;
#define sk_family               __sk_common.skc_family;
#define sk_state                __sk_common.skc_state;
#define sk_reuse                __sk_common.skc_reuse;
#define sk_reuseport            __sk_common.skc_reuseport;
#define sk_ipv6only             __sk_common.skc_ipv6only;
#define sk_net_refcnt           __sk_common.skc_net_refcnt;
#define sk_bound_dev_if         __sk_common.skc_bound_dev_if;
#define sk_bind_node            __sk_common.skc_bind_node;
#define sk_prot                 __sk_common.skc_prot;
#define sk_net                  __sk_common.skc_net;
#define sk_v6_daddr             __sk_common.skc_v6_daddr;
#define sk_v6_rcv_saddr __sk_common.skc_v6_rcv_saddr;
#define sk_cookie               __sk_common.skc_cookie;
#define sk_incoming_cpu         __sk_common.skc_incoming_cpu;
#define sk_flags                __sk_common.skc_flags;
#define sk_rxhash               __sk_common.skc_rxhash;
  socket_lock_t sk_lock;
  atomic_t sk_drops;
  int sk_rcvlowat;
  struct sk_buff_head     sk_error_queue;
  struct sk_buff          *sk_rx_skb_cache;
  struct sk_buff_head     sk_receive_queue;
  struct {
    atomic_t rmem_alloc;
    int len;
    struct sk_buff  *head;
    struct sk_buff  *tail;
  } sk_backlog;
#define sk_rmem_alloc sk_backlog.rmem_alloc;
  int sk_forward_alloc;
#ifdef CONFIG_NET_RX_BUSY_POLL;
  unsigned int            sk_ll_usec;
  unsigned int            sk_napi_id;
#endif;
  int sk_rcvbuf;
  struct sk_filter __rcu  *sk_filter;
  union {
    struct socket_wq __rcu  *sk_wq;
  };
#ifdef CONFIG_XFRM;
  struct xfrm_policy __rcu *sk_policy[2];
#endif;
  struct dst_entry        *sk_rx_dst;
  struct dst_entry __rcu  *sk_dst_cache;
  atomic_t sk_omem_alloc;
  int sk_sndbuf;
  int sk_wmem_queued;
  refcount_t sk_wmem_alloc;
  unsigned long           sk_tsq_flags;
  union {
    struct sk_buff  *sk_send_head;
    struct rb_root  tcp_rtx_queue;
  };
  struct sk_buff          *sk_tx_skb_cache;
  struct sk_buff_head     sk_write_queue;
  __s32 sk_peek_off;
  int sk_write_pending;
  __u32 sk_dst_pending_confirm;
  u32 sk_pacing_status;
  long sk_sndtimeo;
  struct timer_list       sk_timer;
  __u32 sk_priority;
  __u32 sk_mark;
  unsigned long           sk_pacing_rate;
  unsigned long           sk_max_pacing_rate;
  struct page_frag        sk_frag;
  netdev_features_t sk_route_caps;
  netdev_features_t sk_route_nocaps;
  netdev_features_t sk_route_forced_caps;
  int sk_gso_type;
  unsigned int            sk_gso_max_size;
  gfp_t sk_allocation;
  __u32 sk_txhash;
  u8 sk_padding : 1,sk_kern_sock : 1,sk_no_check_tx : 1,sk_no_check_rx : 1, sk_userlocks : 4;
  u8 sk_pacing_shift;
  u16 sk_type;
  u16 sk_protocol;
  u16 sk_gso_max_segs;
  unsigned long           sk_lingertime;
  struct proto            *sk_prot_creator;
  rwlock_t sk_callback_lock;
  int sk_err, sk_err_soft;
  u32 sk_ack_backlog;
  u32 sk_max_ack_backlog;
  kuid_t sk_uid;
  struct pid              *sk_peer_pid;
  const struct cred       *sk_peer_cred;
  long sk_rcvtimeo;
  ktime_t sk_stamp;
#if BITS_PER_LONG==32;
  seqlock_t sk_stamp_seq;
#endif;
  u16 sk_tsflags;
  u8 sk_shutdown;
  u32 sk_tskey;
  atomic_t sk_zckey;
  u8 sk_clockid;
  u8 sk_txtime_deadline_mode : 1,sk_txtime_report_errors : 1, sk_txtime_unused : 6;
  struct socket           *sk_socket;
  void *sk_user_data;
#ifdef CONFIG_SECURITY;
  void *sk_security;
#endif;
  struct sock_cgroup_data sk_cgrp_data;
  struct mem_cgroup       *sk_memcg;
  void (*sk_state_change)(struct sock *sk);
  void (*sk_data_ready)(struct sock *sk);
  void (*sk_write_space)(struct sock *sk);
  void (*sk_error_report)(struct sock *sk);
  int (*sk_backlog_rcv)(struct sock *sk, struct sk_buff *skb);
#ifdef CONFIG_SOCK_VALIDATE_XMIT;
  struct sk_buff*         (*sk_validate_xmit_skb)(struct sock *sk,struct net_device *dev, struct sk_buff *skb);
#endif;
  void (*sk_destruct)(struct sock *sk);
  struct sock_reuseport __rcu     *sk_reuseport_cb;
#ifdef CONFIG_BPF_SYSCALL;
  struct bpf_sk_storage __rcu     *sk_bpf_storage;
#endif;
  struct rcu_head         sk_rcu;
};

Members

__sk_common: shared layout with inet_timewait_sock
sk_lock: synchronizer
sk_drops: raw/udp drops counter
sk_rcvlowat: SO_RCVLOWAT setting
sk_error_queue: rarely used
sk_rx_skb_cache: cache copy of recently accessed RX skb
sk_receive_queue: incoming packets
sk_backlog: always used with the per-socket spinlock held
sk_forward_alloc: space allocated forward
sk_ll_usec: usecs to busypoll when there is no data
sk_napi_id: id of the last napi context to receive data for sk
sk_rcvbuf: size of receive buffer in bytes
sk_filter: socket filtering instructions
{unnamed_union}: anonymous
sk_wq: sock wait queue and async head
sk_policy: flow policy
sk_rx_dst: receive input route used by early demux
sk_dst_cache: destination cache
sk_omem_alloc: “o” is “option” or “other”
sk_sndbuf: size of send buffer in bytes
sk_wmem_queued: persistent queue size
sk_wmem_alloc: transmit queue bytes committed
sk_tsq_flags: TCP Small Queues flags
{unnamed_union}: anonymous
sk_send_head: front of stuff to transmit
tcp_rtx_queue: TCP re-transmit queue [union with sk_send_head]
sk_tx_skb_cache: cache copy of recently accessed TX skb
sk_write_queue: Packet sending queue
sk_peek_off: current peek_offset value
sk_write_pending: a write to stream socket waits to start
sk_dst_pending_confirm: need to confirm neighbour
sk_pacing_status: Pacing status (requested, handled by sch_fq)
sk_sndtimeo: SO_SNDTIMEO setting
sk_timer: sock cleanup timer
sk_priority: SO_PRIORITY setting
sk_mark: generic packet mark
sk_pacing_rate: Pacing rate (if supported by transport/packet scheduler)
sk_max_pacing_rate: Maximum pacing rate (SO_MAX_PACING_RATE)
sk_frag: cached page frag
sk_route_caps: route capabilities (e.g. NETIF_F_TSO)
sk_route_nocaps: forbidden route capabilities (e.g NETIF_F_GSO_MASK)
sk_route_forced_caps: static, forced route capabilities (set in tcp_init_sock())
sk_gso_type: GSO type (e.g. SKB_GSO_TCPV4)
sk_gso_max_size: Maximum GSO segment size to build
sk_allocation: allocation mode
sk_txhash: computed flow hash for use on transmit
sk_padding: unused element for alignment
sk_kern_sock: True if sock is using kernel lock classes
sk_no_check_tx: SO_NO_CHECK setting, set checksum in TX packets
sk_no_check_rx: allow zero checksum in RX packets
sk_userlocks: SO_SNDBUF and SO_RCVBUF settings
sk_pacing_shift: scaling factor for TCP Small Queues
sk_type: socket type (SOCK_STREAM, etc)
sk_protocol: which protocol this socket belongs in this network family
sk_gso_max_segs: Maximum number of GSO segments
sk_lingertime: SO_LINGER l_linger setting
sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt, IPV6_ADDRFORM for instance)
sk_callback_lock: used with the callbacks in the end of this struct
sk_err: last error
sk_err_soft: errors that don’t cause failure but are the cause of a persistent failure not just ‘timed out’
sk_ack_backlog: current listen backlog
sk_max_ack_backlog: listen backlog set in listen()
sk_uid: user id of owner
sk_peer_pid: struct pid for this socket’s peer
sk_peer_cred: SO_PEERCRED setting
sk_rcvtimeo: SO_RCVTIMEO setting
sk_stamp: time stamp of last packet received
sk_stamp_seq: lock for accessing sk_stamp on 32 bit architectures only
sk_tsflags: SO_TIMESTAMPING socket options
sk_shutdown: mask of SEND_SHUTDOWN and/or RCV_SHUTDOWN
sk_tskey: counter to disambiguate concurrent tstamp requests
sk_zckey: counter to order MSG_ZEROCOPY notifications
sk_clockid: clockid used by time-based scheduling (SO_TXTIME)
sk_txtime_deadline_mode: set deadline mode for SO_TXTIME
sk_txtime_report_errors: set report errors mode for SO_TXTIME
sk_txtime_unused: unused txtime flags
sk_socket: Identd and reporting IO signals
sk_user_data: RPC layer private data
sk_security: used by security modules
sk_cgrp_data: cgroup data for this cgroup
sk_memcg: this socket’s memory cgroup association
sk_state_change: callback to indicate change in the state of the sock
sk_data_ready: callback to indicate there is data to be processed
sk_write_space: callback to indicate there is bf sending space available
sk_error_report: callback to indicate errors (e.g. MSG_ERRQUEUE)
sk_backlog_rcv: callback to process the backlog
sk_validate_xmit_skb: ptr to an optional validate function
sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
sk_reuseport_cb: reuseport group container
sk_bpf_storage: ptr to cache and control for bpf_sk_storage
sk_rcu: used during RCU grace period

bool sk_user_data_is_nocopy(const struct sock *sk)¶: Test if sk_user_data pointer must not be copied

Parameters

const struct sock * sk: socket

sk_for_each_entry_offset_rcu ( tpos, pos, head, offset): iterate over a list at a given struct offset

Parameters

tpos: the type * to use as a loop cursor.
pos: the struct hlist_node to use as a loop cursor.
head: the head for your list.
offset: offset of hlist_node within the struct.

void unlock_sock_fast(struct sock *sk, bool slow)¶: complement of lock_sock_fast

Parameters

struct sock * sk: socket
bool slow: slow mode

Description

fast unlock socket for user context. If slow mode is on, we call regular release_sock()

int sk_wmem_alloc_get(const struct sock *sk)¶: returns write allocations

Parameters

const struct sock * sk: socket

Return

sk_wmem_alloc minus initial offset of one

int sk_rmem_alloc_get(const struct sock *sk)¶: returns read allocations

Parameters

const struct sock * sk: socket

Return

sk_rmem_alloc

bool sk_has_allocations(const struct sock *sk)¶: check if allocations are outstanding

Parameters

const struct sock * sk: socket

Return

true if socket has write or read allocations

bool skwq_has_sleeper(struct socket_wq *wq)¶: check if there are any waiting processes

Parameters

struct socket_wq * wq: struct socket_wq

Return

true if socket_wq has waiting processes

The purpose of the skwq_has_sleeper and sock_poll_wait is to wrap the memory barrier call. They were added due to the race found within the tcp code.

Consider following tcp code paths:

CPU1                CPU2
sys_select          receive packet
...                 ...
__add_wait_queue    update tp->rcv_nxt
...                 ...
tp->rcv_nxt check   sock_def_readable
...                 {
schedule               rcu_read_lock();
                       wq = rcu_dereference(sk->sk_wq);
                       if (wq && waitqueue_active(&wq->wait))
                           wake_up_interruptible(&wq->wait)
                       ...
                    }

The race for tcp fires when the __add_wait_queue changes done by CPU1 stay in its cache, and so does the tp->rcv_nxt update on CPU2 side. The CPU1 could then endup calling schedule and sleep forever if there are no more data on the socket.

void sock_poll_wait(struct file *filp, struct socket *sock, poll_table *p)¶: place memory barrier behind the poll_wait call.

Parameters

struct file * filp: file
struct socket * sock: socket to wait on
poll_table * p: poll_table

Description

See the comments in the wq_has_sleeper function.

struct page_frag *sk_page_frag(struct sock *sk)¶: return an appropriate page_frag

Parameters

struct sock * sk: socket

Description

Use the per task page_frag instead of the per socket one for optimization when we know that we’re in the normal context and owns everything that’s associated with current.

gfpflags_allow_blocking() isn’t enough here as direct reclaim may nest inside other socket operations and end up recursing into sk_page_frag() while it’s already in use.

Return

a per task page_frag if context allows that, otherwise a per socket one.

void _sock_tx_timestamp(struct sock *sk, __u16 tsflags, __u8 *tx_flags, __u32 *tskey)¶: checks whether the outgoing packet is to be time stamped

Parameters

struct sock * sk: socket sending this packet
__u16 tsflags: timestamping flags to use
__u8 * tx_flags: completed with instructions for time stamping
__u32 * tskey: filled in with next sk_tskey (not for TCP, which uses seqno)

Note

callers should take care of initial *tx_flags value (usually 0)

void sk_eat_skb(struct sock *sk, struct sk_buff *skb)¶: Release a skb if it is no longer needed

Parameters

struct sock * sk: socket to eat this skb from
struct sk_buff * skb: socket buffer to eat

Description

This routine must be called with interrupts disabled or with the socket locked so that the sk_buff queue operation is ok.

struct sock *skb_steal_sock(struct sk_buff *skb, bool *refcounted)¶: steal a socket from an sk_buff

Parameters

struct sk_buff * skb: sk_buff to steal the socket from
bool * refcounted: is set to true if the socket is reference-counted

struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)¶: Bind a socket to a file

Parameters

struct socket * sock: socket
int flags: file status flags
const char * dname: protocol name

Description

Returns the file bound with sock, implicitly storing it in sock->file. If dname is NULL, sets to “”. On failure the return is a ERR pointer (see linux/err.h). This function uses GFP_KERNEL internally.

struct socket *sock_from_file(struct file *file, int *err)¶: Return the socket bounded to file.

Parameters

struct file * file: file
int * err: pointer to an error code return

Description

On failure returns NULL and assigns -ENOTSOCK to err.

struct socket *sockfd_lookup(int fd, int *err)¶: Go from a file number to its socket slot

Parameters

int fd: file handle
int * err: pointer to an error code return

Description

The file handle passed in is locked and the socket it is bound to is returned. If an error occurs the err pointer is overwritten with a negative errno code and NULL is returned. The function checks for both invalid handles and passing a handle which is not a socket.

On a success the socket object pointer is returned.

struct socket *sock_alloc(void)¶: allocate a socket

Parameters

void: no arguments

Description

Allocate a new inode and socket object. The two are bound together and initialised. The socket is then returned. If we are out of inodes NULL is returned. This functions uses GFP_KERNEL internally.

int sock_sendmsg(struct socket *sock, struct msghdr *msg)¶: send a message through sock

Parameters

struct socket * sock: socket
struct msghdr * msg: message to send

Description

Sends msg through sock, passing through LSM. Returns the number of bytes sent, or an error code.

int kernel_sendmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec, size_t num, size_t size)¶: send a message through sock (kernel-space)

Parameters

struct socket * sock: socket
struct msghdr * msg: message header
struct kvec * vec: kernel vec
size_t num: vec array length
size_t size: total message data size

Description

Builds the message data with vec and sends it through sock. Returns the number of bytes sent, or an error code.

int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg, struct kvec *vec, size_t num, size_t size)¶: send a message through sock (kernel-space)

Parameters

struct sock * sk: sock
struct msghdr * msg: message header
struct kvec * vec: output s/g array
size_t num: output s/g array length
size_t size: total message data size

Description

Builds the message data with vec and sends it through sock. Returns the number of bytes sent, or an error code. Caller must hold sk.

int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)¶: receive a message from sock

Parameters

struct socket * sock: socket
struct msghdr * msg: message to receive
int flags: message flags

Description

Receives msg from sock, passing through LSM. Returns the total number of bytes received, or an error.

int kernel_recvmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec, size_t num, size_t size, int flags)¶: Receive a message from a socket (kernel space)

Parameters

struct socket * sock: The socket to receive the message from
struct msghdr * msg: Received message
struct kvec * vec: Input s/g array for message data
size_t num: Size of input s/g array
size_t size: Number of bytes to read
int flags: Message flags (MSG_DONTWAIT, etc…)

Description

On return the msg structure contains the scatter/gather array passed in the vec argument. The array is modified so that it consists of the unfilled portion of the original array.

The returned value is the total number of bytes received, or an error.

struct ns_common *get_net_ns(struct ns_common *ns)¶: increment the refcount of the network namespace

Parameters

struct ns_common * ns: common namespace (net)

Description

Returns the net’s common namespace.

int sock_create_lite(int family, int type, int protocol, struct socket **res)¶: creates a socket

Parameters

int family: protocol family (AF_INET, …)
int type: communication type (SOCK_STREAM, …)
int protocol: protocol (0, …)
struct socket ** res: new socket

Description

Creates a new socket and assigns it to res, passing through LSM. The new socket initialization is not complete, see kernel_accept(). Returns 0 or an error. On failure res is set to NULL. This function internally uses GFP_KERNEL.

int __sock_create(struct net *net, int family, int type, int protocol, struct socket **res, int kern)¶: creates a socket

Parameters

struct net * net: net namespace
int family: protocol family (AF_INET, …)
int type: communication type (SOCK_STREAM, …)
int protocol: protocol (0, …)
struct socket ** res: new socket
int kern: boolean for kernel space sockets

Description

Creates a new socket and assigns it to res, passing through LSM. Returns 0 or an error. On failure res is set to NULL. kern must be set to true if the socket resides in kernel space. This function internally uses GFP_KERNEL.

int sock_create(int family, int type, int protocol, struct socket **res)¶: creates a socket

Parameters

int family: protocol family (AF_INET, …)
int type: communication type (SOCK_STREAM, …)
int protocol: protocol (0, …)
struct socket ** res: new socket

Description

A wrapper around __sock_create(). Returns 0 or an error. This function internally uses GFP_KERNEL.

int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)¶: creates a socket (kernel space)

Parameters

struct net * net: net namespace
int family: protocol family (AF_INET, …)
int type: communication type (SOCK_STREAM, …)
int protocol: protocol (0, …)
struct socket ** res: new socket

Description

A wrapper around __sock_create(). Returns 0 or an error. This function internally uses GFP_KERNEL.

int sock_register(const struct net_proto_family *ops)¶: add a socket protocol handler

Parameters

const struct net_proto_family * ops: description of protocol

Description

This function is called by a protocol handler that wants to advertise its address family, and have it linked into the socket interface. The value ops->family corresponds to the socket system call protocol family.

void sock_unregister(int family)¶: remove a protocol handler

Parameters

int family: protocol family to remove

Description

This function is called by a protocol handler that wants to remove its address family, and have it unlinked from the new socket creation.

If protocol handler is a module, then it can use module reference counts to protect against new references. If protocol handler is not a module then it needs to provide its own protection in the ops->create routine.

int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)¶: bind an address to a socket (kernel space)

Parameters

struct socket * sock: socket
struct sockaddr * addr: address
int addrlen: length of address

Description

Returns 0 or an error.

int kernel_listen(struct socket *sock, int backlog)¶: move socket to listening state (kernel space)

Parameters

struct socket * sock: socket
int backlog: pending connections queue size

Description

Returns 0 or an error.

int kernel_accept(struct socket *sock, struct socket **newsock, int flags)¶: accept a connection (kernel space)

Parameters

struct socket * sock: listening socket
struct socket ** newsock: new connected socket
int flags: flags

Description

flags must be SOCK_CLOEXEC, SOCK_NONBLOCK or 0. If it fails, newsock is guaranteed to be NULL. Returns 0 or an error.

int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, int flags)¶: connect a socket (kernel space)

Parameters

struct socket * sock: socket
struct sockaddr * addr: address
int addrlen: address length
int flags: flags (O_NONBLOCK, …)

Description

For datagram sockets, addr is the addres to which datagrams are sent by default, and the only address from which datagrams are received. For stream sockets, attempts to connect to addr. Returns 0 or an error code.

int kernel_getsockname(struct socket *sock, struct sockaddr *addr)¶: get the address which the socket is bound (kernel space)

Parameters

struct socket * sock: socket
struct sockaddr * addr: address holder

Description

Fills the addr pointer with the address which the socket is bound. Returns 0 or an error code.

int kernel_getpeername(struct socket *sock, struct sockaddr *addr)¶: get the address which the socket is connected (kernel space)

Parameters

struct socket * sock: socket
struct sockaddr * addr: address holder

Description

Fills the addr pointer with the address which the socket is connected. Returns 0 or an error code.

int kernel_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)¶: get a socket option (kernel space)

Parameters

struct socket * sock: socket
int level: API level (SOL_SOCKET, …)
int optname: option tag
char * optval: option value
int * optlen: option length

Description

Assigns the option length to optlen. Returns 0 or an error.

int kernel_setsockopt(struct socket *sock, int level, int optname, char *optval, unsigned int optlen)¶: set a socket option (kernel space)

Parameters

struct socket * sock: socket
int level: API level (SOL_SOCKET, …)
int optname: option tag
char * optval: option value
unsigned int optlen: option length

Description

Returns 0 or an error.

int kernel_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)¶: send a page through a socket (kernel space)

Parameters

struct socket * sock: socket
struct page * page: page
int offset: page offset
size_t size: total size in bytes
int flags: flags (MSG_DONTWAIT, …)

Description

Returns the total amount sent in bytes or an error.

int kernel_sendpage_locked(struct sock *sk, struct page *page, int offset, size_t size, int flags)¶: send a page through the locked sock (kernel space)

Parameters

struct sock * sk: sock
struct page * page: page
int offset: page offset
size_t size: total size in bytes
int flags: flags (MSG_DONTWAIT, …)

Description

Returns the total amount sent in bytes or an error. Caller must hold sk.

int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)¶: shut down part of a full-duplex connection (kernel space)

Parameters

struct socket * sock: socket
enum sock_shutdown_cmd how: connection part

Description

Returns 0 or an error.

u32 kernel_sock_ip_overhead(struct sock *sk)¶: returns the IP overhead imposed by a socket

Parameters

struct sock * sk: socket

Description

This routine returns the IP overhead imposed by a socket i.e. the length of the underlying IP header, depending on whether this is an IPv4 or IPv6 socket and the length from IP options turned on at the socket. Assumes that the caller has a lock on the socket.

struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, int flags, int node)¶: allocate a network buffer

Parameters

unsigned int size: size to allocate
gfp_t gfp_mask: allocation mask
int flags: If SKB_ALLOC_FCLONE is set, allocate from fclone cache instead of head cache and allocate a cloned (child) skb. If SKB_ALLOC_RX is set, __GFP_MEMALLOC will be used for allocations in case the data is required for writeback
int node: numa node to allocate memory on

Description

Allocate a new sk_buff. The returned buffer has no headroom and a tail room of at least size bytes. The object has a reference count of one. The return is the buffer. On a failure the return is NULL.

Buffers may only be allocated from interrupts using a gfp_mask of GFP_ATOMIC.

struct sk_buff *build_skb_around(struct sk_buff *skb, void *data, unsigned int frag_size)¶: build a network buffer around provided skb

Parameters

struct sk_buff * skb: sk_buff provide by caller, must be memset cleared
void * data: data buffer provided by caller
unsigned int frag_size: size of data, or 0 if head was kmalloced

void *netdev_alloc_frag(unsigned int fragsz)¶: allocate a page fragment

Parameters

unsigned int fragsz: fragment size

Description

Allocates a frag from a page for receive buffer. Uses GFP_ATOMIC allocations.

struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int len, gfp_t gfp_mask)¶: allocate an skbuff for rx on a specific device

Parameters

struct net_device * dev: network device to receive on
unsigned int len: length to allocate
gfp_t gfp_mask: get_free_pages mask, passed to alloc_skb

Description

Allocate a new sk_buff and assign it a usage count of one. The buffer has NET_SKB_PAD headroom built in. Users should allocate the headroom they think they need without accounting for the built in space. The built in space is used for optimisations.

NULL is returned if there is no free memory.

struct sk_buff *__napi_alloc_skb(struct napi_struct *napi, unsigned int len, gfp_t gfp_mask)¶: allocate skbuff for rx in a specific NAPI instance

Parameters

struct napi_struct * napi: napi instance this buffer was allocated for
unsigned int len: length to allocate
gfp_t gfp_mask: get_free_pages mask, passed to alloc_skb and alloc_pages

Description

Allocate a new sk_buff for use in NAPI receive. This buffer will attempt to allocate the head from a special reserved region used only for NAPI Rx allocation. By doing this we can save several CPU cycles by avoiding having to disable and re-enable IRQs.

NULL is returned if there is no free memory.

void __kfree_skb(struct sk_buff *skb)¶: private function

Parameters

struct sk_buff * skb: buffer

Description

Free an sk_buff. Release anything attached to the buffer. Clean the state. This is an internal helper function. Users should always call kfree_skb

void kfree_skb(struct sk_buff *skb)¶: free an sk_buff

Parameters

struct sk_buff * skb: buffer to free

Description

Drop a reference to the buffer and free it if the usage count has hit zero.

void skb_tx_error(struct sk_buff *skb)¶: report an sk_buff xmit error

Parameters

struct sk_buff * skb: buffer that triggered an error

Description

Report xmit error if a device callback is tracking this skb. skb must be freed afterwards.

void consume_skb(struct sk_buff *skb)¶: free an skbuff

Parameters

struct sk_buff * skb: buffer to free

Description

Drop a ref to the buffer and free it if the usage count has hit zero Functions identically to kfree_skb, but kfree_skb assumes that the frame is being dropped after a failure and notes that

struct sk_buff *alloc_skb_for_msg(struct sk_buff *first)¶: allocate sk_buff to wrap frag list forming a msg

Parameters

struct sk_buff * first: first sk_buff of the msg

struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)¶: morph one skb into another

Parameters

struct sk_buff * dst: the skb to receive the contents
struct sk_buff * src: the skb to supply the contents

Description

This is identical to skb_clone except that the target skb is supplied by the user.

The target skb is returned upon exit.

int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)¶: copy userspace skb frags buffers to kernel

Parameters

struct sk_buff * skb: the skb to modify
gfp_t gfp_mask: allocation priority

Description

This must be called on SKBTX_DEV_ZEROCOPY skb. It will copy all frags into kernel and drop the reference to userspace pages.

If this function is called from an interrupt gfp_mask() must be GFP_ATOMIC.

Returns 0 on success or a negative error code on failure to allocate kernel memory to copy to.

struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)¶: duplicate an sk_buff

Parameters

struct sk_buff * skb: buffer to clone
gfp_t gfp_mask: allocation priority

Description

Duplicate an sk_buff. The new one is not owned by a socket. Both copies share the same packet data but not structure. The new buffer has a reference count of 1. If the allocation fails the function returns NULL otherwise the new buffer is returned.

If this function is called from an interrupt gfp_mask() must be GFP_ATOMIC.

struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)¶: create private copy of an sk_buff

Parameters

const struct sk_buff * skb: buffer to copy
gfp_t gfp_mask: allocation priority

Description

Make a copy of both an sk_buff and its data. This is used when the caller wishes to modify the data and needs a private copy of the data to alter. Returns NULL on failure or the pointer to the buffer on success. The returned buffer has a reference count of 1.

As by-product this function converts non-linear sk_buff to linear one, so that sk_buff becomes completely private and caller is allowed to modify all the data of returned buffer. This means that this function is not recommended for use in circumstances when only header is going to be modified. Use pskb_copy() instead.

struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom, gfp_t gfp_mask, bool fclone)¶: create copy of an sk_buff with private head.

Parameters

struct sk_buff * skb: buffer to copy
int headroom: headroom of new skb
gfp_t gfp_mask: allocation priority
bool fclone: if true allocate the copy of the skb from the fclone cache instead of the head cache; it is recommended to set this to true for the cases where the copy will likely be cloned

Description

Make a copy of both an sk_buff and part of its data, located in header. Fragmented data remain shared. This is used when the caller wishes to modify only header of sk_buff and needs private copy of the header to alter. Returns NULL on failure or the pointer to the buffer on success. The returned buffer has a reference count of 1.

int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask)¶: reallocate header of sk_buff

Parameters

struct sk_buff * skb: buffer to reallocate
int nhead: room to add at head
int ntail: room to add at tail
gfp_t gfp_mask: allocation priority

Description

Expands (or creates identical copy, if nhead and ntail are zero) header of skb. sk_buff itself is not changed. sk_buff MUST have reference count of 1. Returns zero in the case of success or error, if expansion failed. In the last case, sk_buff is not changed.

All the pointers pointing into skb header may change and must be reloaded after call to this function.

struct sk_buff *skb_copy_expand(const struct sk_buff *skb, int newheadroom, int newtailroom, gfp_t gfp_mask)¶: copy and expand sk_buff

Parameters

const struct sk_buff * skb: buffer to copy
int newheadroom: new free bytes at head
int newtailroom: new free bytes at tail
gfp_t gfp_mask: allocation priority

Description

Make a copy of both an sk_buff and its data and while doing so allocate additional space.

This is used when the caller wishes to modify the data and needs a private copy of the data to alter as well as more space for new fields. Returns NULL on failure or the pointer to the buffer on success. The returned buffer has a reference count of 1.

You must pass GFP_ATOMIC as the allocation priority if this function is called from an interrupt.

int __skb_pad(struct sk_buff *skb, int pad, bool free_on_error)¶: zero pad the tail of an skb

Parameters

struct sk_buff * skb: buffer to pad
int pad: space to pad
bool free_on_error: free buffer on error

Description

Ensure that a buffer is followed by a padding area that is zero filled. Used by network drivers which may DMA or transfer data beyond the buffer end onto the wire.

May return error in out of memory cases. The skb is freed on error if free_on_error is true.

void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)¶: add data to the tail of a potentially fragmented buffer

Parameters

struct sk_buff * skb: start of the buffer to use
struct sk_buff * tail: tail fragment of the buffer to use
int len: amount of data to add

Description

This function extends the used data area of the potentially fragmented buffer. tail must be the last fragment of skb – or skb itself. If this would exceed the total buffer size the kernel will panic. A pointer to the first byte of the extra data is returned.

void *skb_put(struct sk_buff *skb, unsigned int len)¶: add data to a buffer

Parameters

struct sk_buff * skb: buffer to use
unsigned int len: amount of data to add

Description

This function extends the used data area of the buffer. If this would exceed the total buffer size the kernel will panic. A pointer to the first byte of the extra data is returned.

void *skb_push(struct sk_buff *skb, unsigned int len)¶: add data to the start of a buffer

Parameters

struct sk_buff * skb: buffer to use
unsigned int len: amount of data to add

Description

This function extends the used data area of the buffer at the buffer start. If this would exceed the total buffer headroom the kernel will panic. A pointer to the first byte of the extra data is returned.

void *skb_pull(struct sk_buff *skb, unsigned int len)¶: remove data from the start of a buffer

Parameters

struct sk_buff * skb: buffer to use
unsigned int len: amount of data to remove

Description

This function removes data from the start of a buffer, returning the memory to the headroom. A pointer to the next data in the buffer is returned. Once the data has been pulled future pushes will overwrite the old data.

void skb_trim(struct sk_buff *skb, unsigned int len)¶: remove end from a buffer

Parameters

struct sk_buff * skb: buffer to alter
unsigned int len: new length

Description

Cut the length of a buffer down by removing data from the tail. If the buffer is already under the length specified it is not modified. The skb must be linear.

void *__pskb_pull_tail(struct sk_buff *skb, int delta)¶: advance tail of skb header

Parameters

struct sk_buff * skb: buffer to reallocate
int delta: number of bytes to advance tail

Description

The function makes a sense only on a fragmented sk_buff, it expands header moving its tail forward and copying necessary data from fragmented part.

sk_buff MUST have reference count of 1.

Returns NULL (and sk_buff does not change) if pull failed or value of new tail of skb in the case of success.

All the pointers pointing into skb header may change and must be reloaded after call to this function.

int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)¶: copy bits from skb to kernel buffer

Parameters

const struct sk_buff * skb: source skb
int offset: offset in source
void * to: destination buffer
int len: number of bytes to copy

Description

Copy the specified number of bytes from the source skb to the destination buffer.

CAUTION ! :
If its prototype is ever changed, check arch/{*}/net/{*}.S files, since it is called from BPF assembly code.

int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)¶: store bits from kernel buffer to skb

Parameters

struct sk_buff * skb: destination buffer
int offset: offset in destination
const void * from: source buffer
int len: number of bytes to copy

Description

Copy the specified number of bytes from the source buffer to the destination skb. This function handles all the messy bits of traversing fragment lists and such.

int skb_zerocopy(struct sk_buff *to, struct sk_buff *from, int len, int hlen)¶: Zero copy skb to skb

Parameters

struct sk_buff * to: destination buffer
struct sk_buff * from: source buffer
int len: number of bytes to copy from source buffer
int hlen: size of linear headroom in destination buffer

Description

Copies up to len bytes from from to to by creating references to the frags in the source buffer.

The hlen as calculated by skb_zerocopy_headlen() specifies the headroom in the to buffer.

Return value: 0: everything is OK -ENOMEM: couldn’t orphan frags of from due to lack of memory -EFAULT: skb_copy_bits() found some problem with skb geometry

struct sk_buff *skb_dequeue(struct sk_buff_head *list)¶: remove from the head of the queue

Parameters

struct sk_buff_head * list: list to dequeue from

Description

Remove the head of the list. The list lock is taken so the function may be used safely with other locking list functions. The head item is returned or NULL if the list is empty.

struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)¶: remove from the tail of the queue

Parameters

struct sk_buff_head * list: list to dequeue from

Description

Remove the tail of the list. The list lock is taken so the function may be used safely with other locking list functions. The tail item is returned or NULL if the list is empty.

void skb_queue_purge(struct sk_buff_head *list)¶: empty a list

Parameters

struct sk_buff_head * list: list to empty

Description

Delete all buffers on an sk_buff list. Each buffer is removed from the list and one reference dropped. This function takes the list lock and is atomic with respect to other list locking functions.

void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)¶: queue a buffer at the list head

Parameters

struct sk_buff_head * list: list to use
struct sk_buff * newsk: buffer to queue

Description

Queue a buffer at the start of the list. This function takes the list lock and can be used safely with other locking sk_buff functions safely.

A buffer cannot be placed on two lists at the same time.

void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)¶: queue a buffer at the list tail

Parameters

struct sk_buff_head * list: list to use
struct sk_buff * newsk: buffer to queue

Description

Queue a buffer at the tail of the list. This function takes the list lock and can be used safely with other locking sk_buff functions safely.

A buffer cannot be placed on two lists at the same time.

void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)¶: remove a buffer from a list

Parameters

struct sk_buff * skb: buffer to remove
struct sk_buff_head * list: list to use

Description

Remove a packet from a list. The list locks are taken and this function is atomic with respect to other list locked calls

You must know what list the SKB is on.

void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)¶: append a buffer

Parameters

struct sk_buff * old: buffer to insert after
struct sk_buff * newsk: buffer to insert
struct sk_buff_head * list: list to use

Description

Place a packet after a given packet in a list. The list locks are taken and this function is atomic with respect to other list locked calls. A buffer cannot be placed on two lists at the same time.

void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)¶: Split fragmented skb to two parts at length len.

Parameters

struct sk_buff * skb: the buffer to split
struct sk_buff * skb1: the buffer to receive the second part
const u32 len: new length for skb

void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from, unsigned int to, struct skb_seq_state *st)¶: Prepare a sequential read of skb data

Parameters

struct sk_buff * skb: the buffer to read
unsigned int from: lower offset of data to be read
unsigned int to: upper offset of data to be read
struct skb_seq_state * st: state variable

Description

Initializes the specified state variable. Must be called before invoking skb_seq_read() for the first time.

unsigned int skb_seq_read(unsigned int consumed, const u8 **data, struct skb_seq_state *st)¶: Sequentially read skb data

Parameters

unsigned int consumed: number of bytes consumed by the caller so far
const u8 ** data: destination pointer for data to be returned
struct skb_seq_state * st: state variable

Description

Reads a block of skb data at consumed relative to the lower offset specified to skb_prepare_seq_read(). Assigns the head of the data block to data and returns the length of the block or 0 if the end of the skb data or the upper offset has been reached.

The caller is not required to consume all of the data returned, i.e. consumed is typically set to the number of bytes already consumed and the next call to skb_seq_read() will return the remaining part of the block.

Note 1: The size of each block of data returned can be arbitrary,: this limitation is the cost for zerocopy sequential reads of potentially non linear data.
Note 2: Fragment lists within fragments are not implemented: at the moment, state->root_skb could be replaced with a stack for this purpose.

void skb_abort_seq_read(struct skb_seq_state *st)¶: Abort a sequential read of skb data

Parameters

struct skb_seq_state * st: state variable

Description

Must be called if skb_seq_read() was not called until it returned 0.

unsigned int skb_find_text(struct sk_buff *skb, unsigned int from, unsigned int to, struct ts_config *config)¶: Find a text pattern in skb data

Parameters

struct sk_buff * skb: the buffer to look in
unsigned int from: search offset
unsigned int to: search limit
struct ts_config * config: textsearch configuration

Description

Finds a pattern in the skb data according to the specified textsearch configuration. Use textsearch_next() to retrieve subsequent occurrences of the pattern. Returns the offset to the first occurrence or UINT_MAX if no match was found.

void *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)¶: pull skb and update receive checksum

Parameters

struct sk_buff * skb: buffer to update
unsigned int len: length of data pulled

Description

This function performs an skb_pull on the packet and updates the CHECKSUM_COMPLETE checksum. It should be used on receive path processing instead of skb_pull unless you know that the checksum difference is zero (e.g., a valid IP header) or you are setting ip_summed to CHECKSUM_NONE.

struct sk_buff *skb_segment(struct sk_buff *head_skb, netdev_features_t features)¶: Perform protocol segmentation on skb.

Parameters

struct sk_buff * head_skb: buffer to segment
netdev_features_t features: features for the output path (see dev->features)

Description

This function performs segmentation on the given skb. It returns a pointer to the first in a list of new skbs for the segments. In case of error it returns ERR_PTR(err).

int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)¶: Fill a scatter-gather list from a socket buffer

Parameters

struct sk_buff * skb: Socket buffer containing the buffers to be mapped
struct scatterlist * sg: The scatter-gather list to map into
int offset: The offset into the buffer’s contents to start mapping
int len: Length of buffer space to be mapped

Description

Fill the specified scatter-gather list with mappings/pointers into a region of the buffer space attached to a socket buffer. Returns either the number of scatterlist items used, or -EMSGSIZE if the contents could not fit.

int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)¶: Check that a socket buffer’s data buffers are writable

Parameters

struct sk_buff * skb: The socket buffer to check.
int tailbits: Amount of trailing space to be added
struct sk_buff ** trailer: Returned pointer to the skb where the tailbits space begins

Description

Make sure that the data buffers attached to a socket buffer are writable. If they are not, private copies are made of the data buffers and the socket buffer is set to use these instead.

If tailbits is given, make sure that there is space to write tailbits bytes of data beyond current end of socket buffer. trailer will be set to point to the skb in which this space begins.

The number of scatterlist elements required to completely map the COW’d and extended socket buffer will be returned.

struct sk_buff *skb_clone_sk(struct sk_buff *skb)¶: create clone of skb, and take reference to socket

Parameters

struct sk_buff * skb: the skb to clone

Description

This function creates a clone of a buffer that holds a reference on sk_refcnt. Buffers created via this function are meant to be returned using sock_queue_err_skb, or free via kfree_skb.

When passing buffers allocated with this function to sock_queue_err_skb it is necessary to wrap the call with sock_hold/sock_put in order to prevent the socket from being released prior to being enqueued on the sk_error_queue.

bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)¶: set up and verify partial csum values for packet

Parameters

struct sk_buff * skb: the skb to set
u16 start: the number of bytes after skb->data to start checksumming.
u16 off: the offset from start to place the checksum.

Description

For untrusted partially-checksummed packets, we need to make sure the values for skb->csum_start and skb->csum_offset are valid so we don’t oops.

This function checks and sets those values and skb->ip_summed: if this returns false you should drop the packet.

int skb_checksum_setup(struct sk_buff *skb, bool recalculate)¶: set up partial checksum offset

Parameters

struct sk_buff * skb: the skb to set up
bool recalculate: if true the pseudo-header checksum will be recalculated

struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb, unsigned int transport_len, __sum16 (*skb_chkf)(struct sk_buff *skb))¶: validate checksum of an skb

Parameters

struct sk_buff * skb: the skb to check
unsigned int transport_len: the data length beyond the network header
__sum16(*)(struct sk_buff *skb) skb_chkf: checksum function to use

Description

Applies the given checksum function skb_chkf to the provided skb. Returns a checked and maybe trimmed skb. Returns NULL on error.

If the skb has data beyond the given transport length, then a trimmed & cloned skb is checked and returned.

Caller needs to set the skb transport header and free any returned skb if it differs from the provided skb.

bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from, bool *fragstolen, int *delta_truesize)¶: try to merge skb to prior one

Parameters

struct sk_buff * to: prior buffer
struct sk_buff * from: buffer to add
bool * fragstolen: pointer to boolean
int * delta_truesize: how much more was allocated than was requested

void skb_scrub_packet(struct sk_buff *skb, bool xnet)¶: scrub an skb

Parameters

struct sk_buff * skb: buffer to clean
bool xnet: packet is crossing netns

Description

skb_scrub_packet can be used after encapsulating or decapsulting a packet into/from a tunnel. Some information have to be cleared during these operations. skb_scrub_packet can also be used to clean a skb before injecting it in another namespace (xnet == true). We have to clear all information in the skb that could impact namespace isolation.

bool skb_gso_validate_network_len(const struct sk_buff *skb, unsigned int mtu)¶: Will a split GSO skb fit into a given MTU?

Parameters

const struct sk_buff * skb: GSO skb
unsigned int mtu: MTU to validate against

Description

skb_gso_validate_network_len validates if a given skb will fit a wanted MTU once split. It considers L3 headers, L4 headers, and the payload.

bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len)¶: Will a split GSO skb fit in a given length?

Parameters

const struct sk_buff * skb: GSO skb
unsigned int len: length to validate against

Description

skb_gso_validate_mac_len validates if a given skb will fit a wanted length once split, including L2, L3 and L4 headers and the payload.

int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto, int mac_len, bool ethernet)¶: push a new MPLS header after mac_len bytes from start of the packet

Parameters

struct sk_buff * skb: buffer
__be32 mpls_lse: MPLS label stack entry to push
__be16 mpls_proto: ethertype of the new MPLS header (expects 0x8847 or 0x8848)
int mac_len: length of the MAC header
bool ethernet: flag to indicate if the resulting packet after skb_mpls_push is ethernet

Description

Expects skb->data at mac header.

Returns 0 on success, -errno otherwise.

int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len, bool ethernet)¶: pop the outermost MPLS header

Parameters

struct sk_buff * skb: buffer
__be16 next_proto: ethertype of header after popped MPLS header
int mac_len: length of the MAC header
bool ethernet: flag to indicate if the packet is ethernet

Description

Expects skb->data at mac header.

Returns 0 on success, -errno otherwise.

int skb_mpls_update_lse(struct sk_buff *skb, __be32 mpls_lse)¶: modify outermost MPLS header and update csum

Parameters

struct sk_buff * skb: buffer
__be32 mpls_lse: new MPLS label stack entry to update to

Description

Expects skb->data at mac header.

Returns 0 on success, -errno otherwise.

int skb_mpls_dec_ttl(struct sk_buff *skb)¶: decrement the TTL of the outermost MPLS header

Parameters

struct sk_buff * skb: buffer

Description

Expects skb->data at mac header.

Returns 0 on success, -errno otherwise.

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)¶: allocate skb with page frags

Parameters

unsigned long header_len: size of linear part
unsigned long data_len: needed length in frags
int max_page_order: max page order desired.
int * errcode: pointer to error code if any
gfp_t gfp_mask: allocation mask

Description

This can be used to allocate a paged skb, given a maximal order for frags.

void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id)¶: allocate space for given extension, COW if needed

Parameters

struct sk_buff * skb: buffer
enum skb_ext_id id: extension to allocate space for

Description

Allocates enough space for the given extension. If the extension is already present, a pointer to that extension is returned.

If the skb was cloned, COW applies and the returned memory can be modified without changing the extension space of clones buffers.

Returns pointer to the extension or NULL on allocation failure.

bool sk_ns_capable(const struct sock *sk, struct user_namespace *user_ns, int cap)¶: General socket capability test

Parameters

const struct sock * sk: Socket to use a capability on or through
struct user_namespace * user_ns: The user namespace of the capability to use
int cap: The capability to use

Description

Test to see if the opener of the socket had when the socket was created and the current process has the capability cap in the user namespace user_ns.

bool sk_capable(const struct sock *sk, int cap)¶: Socket global capability test

Parameters

const struct sock * sk: Socket to use a capability on or through
int cap: The global capability to use

Description

Test to see if the opener of the socket had when the socket was created and the current process has the capability cap in all user namespaces.

bool sk_net_capable(const struct sock *sk, int cap)¶: Network namespace socket capability test

Parameters

const struct sock * sk: Socket to use a capability on or through
int cap: The capability to use

Description

Test to see if the opener of the socket had when the socket was created and the current process has the capability cap over the network namespace the socket is a member of.

void sk_set_memalloc(struct sock *sk)¶: sets SOCK_MEMALLOC

Parameters

struct sock * sk: socket to set it on

Description

Set SOCK_MEMALLOC on a socket for access to emergency reserves. It’s the responsibility of the admin to adjust min_free_kbytes to meet the requirements

struct sock *sk_alloc(struct net *net, int family, gfp_t priority, struct proto *prot, int kern)¶: All socket objects are allocated here

Parameters

struct net * net: the applicable net namespace
int family: protocol family
gfp_t priority: for allocation (GFP_KERNEL, GFP_ATOMIC, etc)
struct proto * prot: struct proto associated with this new sock instance
int kern: is this to be a kernel socket?

struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)¶: clone a socket, and lock its clone

Parameters

const struct sock * sk: the socket to clone
const gfp_t priority: for allocation (GFP_KERNEL, GFP_ATOMIC, etc)

Description

Caller must unlock socket even in error path (bh_unlock_sock(newsk))

bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)¶: check that a page_frag contains enough room

Parameters

unsigned int sz: minimum size of the fragment we want to get
struct page_frag * pfrag: pointer to page_frag
gfp_t gfp: priority for memory allocation

Note

While this allocator tries to use high order pages, there is no guarantee that allocations succeed. Therefore, sz MUST be less or equal than PAGE_SIZE.

int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)¶: wait for data to arrive at sk_receive_queue

Parameters

struct sock * sk: sock to wait on
long * timeo: for how long
const struct sk_buff * skb: last skb seen on sk_receive_queue

Description

Now socket state including sk->sk_err is changed only under lock, hence we may omit checks after joining wait queue. We check receive queue before schedule() only as optimization; it is very likely that release_sock() added new data.

int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)¶: increase memory_allocated

Parameters

struct sock * sk: socket
int size: memory size to allocate
int amt: pages to allocate
int kind: allocation type

Description

Similar to __sk_mem_schedule(), but does not update sk_forward_alloc

int __sk_mem_schedule(struct sock *sk, int size, int kind)¶: increase sk_forward_alloc and memory_allocated

Parameters

struct sock * sk: socket
int size: memory size to allocate
int kind: allocation type

Description

If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means rmem allocation. This function assumes that protocols which have memory_pressure use sk_wmem_queued as write buffer accounting.

void __sk_mem_reduce_allocated(struct sock *sk, int amount)¶: reclaim memory_allocated

Parameters

struct sock * sk: socket
int amount: number of quanta

Description

Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc

void __sk_mem_reclaim(struct sock *sk, int amount)¶: reclaim sk_forward_alloc and memory_allocated

Parameters

struct sock * sk: socket
int amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)

bool lock_sock_fast(struct sock *sk)¶: fast version of lock_sock

Parameters

struct sock * sk: socket

Description

This version should be used for very small section, where process wont block return false if fast path is taken:

sk_lock.slock locked, owned = 0, BH disabled

return true if slow path is taken:

sk_lock.slock unlocked, owned = 1, BH enabled

struct sk_buff *__skb_try_recv_datagram(struct sock *sk, struct sk_buff_head *queue, unsigned int flags, int *off, int *err, struct sk_buff **last)¶: Receive a datagram skbuff

Parameters

struct sock * sk: socket
struct sk_buff_head * queue: socket queue from which to receive
unsigned int flags: MSG_ flags
int * off: an offset in bytes to peek skb from. Returns an offset within an skb where data actually starts
int * err: error code returned
struct sk_buff ** last: set to last peeked message to inform the wait function what to look for when peeking

Description

Get a datagram skbuff, understands the peeking, nonblocking wakeups and possible races. This replaces identical code in packet, raw and udp, as well as the IPX AX.25 and Appletalk. It also finally fixes the long standing peek and read race for datagram sockets. If you alter this routine remember it must be re-entrant.

This function will lock the socket if a skb is returned, so the caller needs to unlock the socket in that case (usually by calling skb_free_datagram). Returns NULL with err set to -EAGAIN if no data was available or to some other value if an error was detected.

It does not lock socket since today. This function is

free of race conditions. This measure should/can improve

significantly datagram socket latencies at high loads,

when data copying to user space takes lots of time.

(BTW I’ve just killed the last cli() in IP/IPv6/core/netlink/packet

Great win.)

–ANK (980729)

The order of the tests when we find no data waiting are specified quite explicitly by POSIX 1003.1g, don’t change them without having the standard around please.

int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags)¶: Free a datagram skbuff forcibly

Parameters

struct sock * sk: socket
struct sk_buff * skb: datagram skbuff
unsigned int flags: MSG_ flags

Description

This function frees a datagram skbuff that was received by skb_recv_datagram. The flags argument must match the one used for skb_recv_datagram.

If the MSG_PEEK flag is set, and the packet is still on the receive queue of the socket, it will be taken off the queue before it is freed.

This function currently only disables BH when acquiring the sk_receive_queue lock. Therefore it must not be used in a context where that lock is acquired in an IRQ context.

It returns 0 if the packet was removed by us.

int skb_copy_and_hash_datagram_iter(const struct sk_buff *skb, int offset, struct iov_iter *to, int len, struct ahash_request *hash)¶: Copy datagram to an iovec iterator and update a hash.

Parameters

const struct sk_buff * skb: buffer to copy
int offset: offset in the buffer to start copying from
struct iov_iter * to: iovec iterator to copy to
int len: amount of data to copy from buffer to iovec
struct ahash_request * hash: hash request to update

int skb_copy_datagram_iter(const struct sk_buff *skb, int offset, struct iov_iter *to, int len)¶: Copy a datagram to an iovec iterator.

Parameters

const struct sk_buff * skb: buffer to copy
int offset: offset in the buffer to start copying from
struct iov_iter * to: iovec iterator to copy to
int len: amount of data to copy from buffer to iovec

int skb_copy_datagram_from_iter(struct sk_buff *skb, int offset, struct iov_iter *from, int len)¶: Copy a datagram from an iov_iter.

Parameters

struct sk_buff * skb: buffer to copy
int offset: offset in the buffer to start copying to
struct iov_iter * from: the copy source
int len: amount of data to copy to buffer from iovec

Description

Returns 0 or -EFAULT.

int zerocopy_sg_from_iter(struct sk_buff *skb, struct iov_iter *from)¶: Build a zerocopy datagram from an iov_iter

Parameters

struct sk_buff * skb: buffer to copy
struct iov_iter * from: the source to copy from

Description

The function will first copy up to headlen, and then pin the userspace pages and build frags through them.

Returns 0, -EFAULT or -EMSGSIZE.

int skb_copy_and_csum_datagram_msg(struct sk_buff *skb, int hlen, struct msghdr *msg)¶: Copy and checksum skb to user iovec.

Parameters

struct sk_buff * skb: skbuff
int hlen: hardware length
struct msghdr * msg: destination

Description

Caller _must_ check that skb will fit to this iovec.

Return

0 - success.: -EINVAL - checksum failure. -EFAULT - fault during copy.

__poll_t datagram_poll(struct file *file, struct socket *sock, poll_table *wait)¶: generic datagram poll

Parameters

struct file * file: file struct
struct socket * sock: socket
poll_table * wait: poll table

Description

Datagram poll: Again totally generic. This also handles sequenced packet sockets providing the socket receive queue is only ever holding data ready to receive.

Note

when you don’t use this routine for this protocol,: and you use a different write policy from sock_writeable() then please supply your own write_space callback.

int sk_stream_wait_connect(struct sock *sk, long *timeo_p)¶: Wait for a socket to get into the connected state

Parameters

struct sock * sk: sock to wait on
long * timeo_p: for how long to wait

Description

Must be called with the socket locked.

int sk_stream_wait_memory(struct sock *sk, long *timeo_p)¶: Wait for more memory for a socket

Parameters

struct sock * sk: socket to wait for memory
long * timeo_p: for how long

Socket Filter¶

int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap)¶: run a packet through a socket filter

Parameters

struct sock * sk: sock associated with sk_buff
struct sk_buff * skb: buffer to filter
unsigned int cap: limit on how short the eBPF program may trim the packet

Description

Run the eBPF program and then cut skb->data to correct size returned by the program. If pkt_len is 0 we toss packet. If skb->len is smaller than pkt_len we keep whole skb->data. This is the socket level wrapper to BPF_PROG_RUN. It returns 0 if the packet should be accepted or -EPERM if the packet should be tossed.

int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog)¶: create an unattached filter

Parameters

struct bpf_prog ** pfp: the unattached filter that is created
struct sock_fprog_kern * fprog: the filter program

Description

Create a filter independent of any socket. We first run some sanity checks on it to make sure it does not explode on us later. If an error occurs or there is insufficient memory for the filter a negative errno code is returned. On success the return is zero.

int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog, bpf_aux_classic_check_t trans, bool save_orig)¶: create an unattached filter from user buffer

Parameters

struct bpf_prog ** pfp: the unattached filter that is created
struct sock_fprog * fprog: the filter program
bpf_aux_classic_check_t trans: post-classic verifier transformation handler
bool save_orig: save classic BPF program

Description

This function effectively does the same as bpf_prog_create(), only that it builds up its insns buffer from user space provided buffer. It also allows for passing a bpf_aux_classic_check_t handler.

int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)¶: attach a socket filter

Parameters

struct sock_fprog * fprog: the filter program
struct sock * sk: the socket to use

Description

Attach the user’s filter code. We first run some sanity checks on it to make sure it does not explode on us later. If an error occurs or there is insufficient memory for the filter a negative errno code is returned. On success the return is zero.

Generic Network Statistics¶

struct gnet_stats_basic: byte/packet throughput statistics

Definition

struct gnet_stats_basic {
  __u64 bytes;
  __u32 packets;
};

Members

bytes: number of seen bytes
packets: number of seen packets

struct gnet_stats_rate_est: rate estimator

Definition

struct gnet_stats_rate_est {
  __u32 bps;
  __u32 pps;
};

Members

bps: current byte rate
pps: current packet rate

struct gnet_stats_rate_est64: rate estimator

Definition

struct gnet_stats_rate_est64 {
  __u64 bps;
  __u64 pps;
};

Members

bps: current byte rate
pps: current packet rate

struct gnet_stats_queue: queuing statistics

Definition

struct gnet_stats_queue {
  __u32 qlen;
  __u32 backlog;
  __u32 drops;
  __u32 requeues;
  __u32 overlimits;
};

Members

qlen: queue length
backlog: backlog size of queue
drops: number of dropped packets
requeues: number of requeues
overlimits: number of enqueues over the limit

struct gnet_estimator: rate estimator configuration

Definition

struct gnet_estimator {
  signed char     interval;
  unsigned char   ewma_log;
};

Members

interval: sampling period
ewma_log: the log of measurement window weight

int gnet_stats_start_copy_compat(struct sk_buff *skb, int type, int tc_stats_type, int xstats_type, spinlock_t *lock, struct gnet_dump *d, int padattr)¶: start dumping procedure in compatibility mode

Parameters

struct sk_buff * skb: socket buffer to put statistics TLVs into
int type: TLV type for top level statistic TLV
int tc_stats_type: TLV type for backward compatibility struct tc_stats TLV
int xstats_type: TLV type for backward compatibility xstats TLV
spinlock_t * lock: statistics lock
struct gnet_dump * d: dumping handle
int padattr: padding attribute

Description

Initializes the dumping handle, grabs the statistic lock and appends an empty TLV header to the socket buffer for use a container for all other statistic TLVS.

The dumping handle is marked to be in backward compatibility mode telling all gnet_stats_copy_XXX() functions to fill a local copy of struct tc_stats.

Returns 0 on success or -1 if the room in the socket buffer was not sufficient.

int gnet_stats_start_copy(struct sk_buff *skb, int type, spinlock_t *lock, struct gnet_dump *d, int padattr)¶: start dumping procedure in compatibility mode

Parameters

struct sk_buff * skb: socket buffer to put statistics TLVs into
int type: TLV type for top level statistic TLV
spinlock_t * lock: statistics lock
struct gnet_dump * d: dumping handle
int padattr: padding attribute

Description

Initializes the dumping handle, grabs the statistic lock and appends an empty TLV header to the socket buffer for use a container for all other statistic TLVS.

Returns 0 on success or -1 if the room in the socket buffer was not sufficient.

int gnet_stats_copy_basic (const seqcount_t * running, struct gnet_dump * d, struct gnet_stats_basic_cpu __percpu * cpu, struct gnet_stats_basic_packed * b): copy basic statistics into statistic TLV

Parameters

const seqcount_t * running: seqcount_t pointer
struct gnet_dump * d: dumping handle
struct gnet_stats_basic_cpu __percpu * cpu: copy statistic per cpu
struct gnet_stats_basic_packed * b: basic statistics

Description

Appends the basic statistics to the top level TLV created by gnet_stats_start_copy().