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.

struct socket¶: general BSD socket

Definition

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

Members

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

Socket Buffer Functions¶

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 {unnamed_union};
  __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;
  unsigned char * data;
  unsigned int truesize;
  refcount_t users;
};

Members

{unnamed_union}: anonymous
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

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

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.

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_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

Description

Drop a reference to the header part of the buffer. This is done by acquiring a payload reference. You must not read from the header part of skb->data after this.

Note

Check if you can use __skb_header_release() instead.

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

Parameters

struct sk_buff * skb: buffer to operate on

Description

Variant of skb_header_release() assuming skb is private to caller. We can avoid one atomic operation.

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_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.

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

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_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)¶: 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.

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 timeval * stamp)¶: get timestamp from a skb

Parameters

const struct sk_buff * skb: skb to get stamp from
struct timeval * stamp: pointer to struct 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.

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.

unsigned int skb_gso_network_seglen(const struct sk_buff * skb)¶: Return length of individual segments of a gso packet

Parameters

const struct sk_buff * skb: GSO skb

Description

skb_gso_network_seglen is used to determine the real size of the individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP).

The MAC/L2 header is not accounted for.

struct sock_common¶: minimal network layer representation of sockets

Definition

struct sock_common {
  union {unnamed_union};
};

Members

{unnamed_union}: anonymous

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
#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_head sk_receive_queue;
  struct {unnamed_struct};
#ifdef CONFIG_XFRM
  struct xfrm_policy __rcu * sk_policy;
#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;
  struct sk_buff * sk_send_head;
  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;
  u32 sk_pacing_rate;
  u32 sk_max_pacing_rate;
  struct page_frag sk_frag;
  netdev_features_t sk_route_caps;
  netdev_features_t sk_route_nocaps;
  int sk_gso_type;
  unsigned int sk_gso_max_size;
  gfp_t sk_allocation;
  __u32 sk_txhash;
  unsigned int __sk_flags_offset;
#ifdef __BIG_ENDIAN_BITFIELD
#define SK_FL_PROTO_SHIFT  16
#define SK_FL_PROTO_MASK   0x00ff0000
#define SK_FL_TYPE_SHIFT   0
#define SK_FL_TYPE_MASK    0x0000ffff
#else
#define SK_FL_PROTO_SHIFT  8
#define SK_FL_PROTO_MASK   0x0000ff00
#define SK_FL_TYPE_SHIFT   16
#define SK_FL_TYPE_MASK    0xffff0000
#endif
  unsigned int sk_padding:1;
  unsigned int sk_kern_sock:1;
  unsigned int sk_no_check_tx:1;
  unsigned int sk_no_check_rx:1;
  unsigned int sk_userlocks:4;
  unsigned int sk_protocol:8;
  unsigned int sk_type:16;
#define SK_PROTOCOL_MAX U8_MAX
  u16 sk_gso_max_segs;
  unsigned long sk_lingertime;
  struct proto * sk_prot_creator;
  rwlock_t sk_callback_lock;
  int sk_err;
  int 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;
  u16 sk_tsflags;
  u8 sk_shutdown;
  u32 sk_tskey;
  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);
  void (* sk_destruct) (struct sock *sk);
  struct sock_reuseport __rcu * sk_reuseport_cb;
  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_receive_queue: incoming packets
{unnamed_struct}: anonymous
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
sk_send_head: front of stuff to transmit
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_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_flags_offset: empty field used to determine location of bitfield
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_protocol: which protocol this socket belongs in this network family
sk_type: socket type (SOCK_STREAM, etc)
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_tsflags: SO_TIMESTAMPING socket options
sk_shutdown: mask of SEND_SHUTDOWN and/or RCV_SHUTDOWN
sk_tskey: counter to disambiguate concurrent tstamp requests
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_destruct: called at sock freeing time, i.e. when all refcnt == 0
sk_reuseport_cb: reuseport group container
sk_rcu: used during RCU grace period

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

Description

Returns 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

Description

Returns sk_rmem_alloc

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

Parameters

const struct sock * sk: socket

Description

Returns 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

Description

Returns 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               :c:func:`rcu_read_lock()`;
                       wq = rcu_dereference(sk->sk_wq);
                       if (wq && waitqueue_active(:c:type:`wq->wait <wq>`))
                           wake_up_interruptible(:c:type:`wq->wait <wq>`)
                       ...
                    }

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, wait_queue_head_t * wait_address, poll_table * p)¶: place memory barrier behind the poll_wait call.

Parameters

struct file * filp: file
wait_queue_head_t * wait_address: socket wait queue
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

If socket allocation mode allows current thread to sleep, it means its safe to use the per task page_frag instead of the per socket one.

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

Parameters

const struct sock * sk: socket sending this packet
__u16 tsflags: timestamping flags to use
__u8 * tx_flags: completed with instructions for time stamping

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.

int sk_state_load(const struct sock * sk)¶: read sk->sk_state for lockless contexts

Parameters

const struct sock * sk: socket pointer

Description

Paired with sk_state_store(). Used in places we do not hold socket lock : tcp_diag_get_info(), tcp_get_info(), tcp_poll(), get_tcp4_sock() ...

void sk_state_store(struct sock * sk, int newstate)¶: update sk->sk_state

Parameters

struct sock * sk: socket pointer
int newstate: new state

Description

Paired with sk_state_load(). Should be used in contexts where state change might impact lockless readers.

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.

void sock_release(struct socket * sock)¶: close a socket

Parameters

struct socket * sock: socket to close

Description

The socket is released from the protocol stack if it has a release callback, and the inode is then released if the socket is bound to an inode not a file.

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.

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.

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.

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 * 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)¶: 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.

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_insert(struct sk_buff * old, struct sk_buff * newsk, struct sk_buff_head * list)¶: insert a buffer

Parameters

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

Description

Place a packet before 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.

int skb_append_datato_frags(struct sock * sk, struct sk_buff * skb, int (*getfrag) (void *from, char *to, int offset, int len, int odd, struct sk_buff *skb, void * from, int length)¶: append the user data to a skb

Parameters

struct sock * sk: sock structure
struct sk_buff * skb: skb structure to be appended with user data.
int (*)(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb) getfrag: call back function to be used for getting the user data
void * from: pointer to user message iov
int length: length of the iov message

Description

This procedure append the user data in the fragment part of the skb if any page alloc fails user this procedure returns -ENOMEM

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.

unsigned int skb_gso_transport_seglen(const struct sk_buff * skb)¶: Return length of individual segments of a gso packet

Parameters

const struct sk_buff * skb: GSO skb

Description

skb_gso_transport_seglen is used to determine the real size of the individual segments, including Layer4 headers (TCP/UDP).

The MAC/L2 or network (IP, IPv6) headers are not accounted for.

bool skb_gso_validate_mtu(const struct sk_buff * skb, unsigned int mtu)¶: Return in case such skb fits a given MTU

Parameters

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

Description

skb_gso_validate_mtu validates if a given skb will fit a wanted MTU once split.

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.

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, unsigned int flags, void (*destructor) (struct sock *sk, struct sk_buff *skb, int * peeked, int * off, int * err, struct sk_buff ** last)¶: Receive a datagram skbuff

Parameters

struct sock * sk: socket
unsigned int flags: MSG_ flags
void (*)(struct sock *sk, struct sk_buff *skb) destructor: invoked under the receive lock on successful dequeue
int * peeked: returns non-zero if this packet has been seen before
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_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.

unsigned int 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().