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.

Constants

SHUT_RD

shutdown receptions

SHUT_WR

shutdown transmissions

SHUT_RDWR

shutdown receptions/transmissions

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

Parameters

constskb_frag_t*frag

skb fragment

Parameters

skb_frag_t*frag

skb fragment

unsignedintsize

size of fragment

Parameters

skb_frag_t*frag

skb fragment

intdelta

value to add

Parameters

skb_frag_t*frag

skb fragment

intdelta

value to subtract

Parameters

structpage*p

fragment’s page

Parameters

f

skb frag to operate on

f_off

offset from start of f->netmem

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-pageoperations, notably kmap_atomic, must be called for eachregular page.

Definition:

struct skb_shared_hwtstamps {    union {        ktime_t hwtstamp;        void *netdev_data;    };};

Members

{unnamed_union}

anonymous

hwtstamp

hardware time stamp transformed into durationsince arbitrary point in time

netdev_data

address/cookie of network device driver used asreference to actual hardware time stamp

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;        struct llist_node       ll_node;    };    struct sock             *sk;    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;#ifdef CONFIG_NET_SOCK_MSG;        unsigned long           _sk_redir;#endif;    };#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, pp_recycle:1;#ifdef CONFIG_SKB_EXTENSIONS;    __u8 active_extensions;#endif;    __u8 pkt_type:3;    __u8 ignore_df:1;    __u8 dst_pending_confirm:1;    __u8 ip_summed:2;    __u8 ooo_okay:1;    __u8 tstamp_type:2;#ifdef CONFIG_NET_XGRESS;    __u8 tc_at_ingress:1;    __u8 tc_skip_classify:1;#endif;    __u8 remcsum_offload:1;    __u8 csum_complete_sw:1;    __u8 csum_level:2;    __u8 inner_protocol_type:1;    __u8 l4_hash:1;    __u8 sw_hash:1;#ifdef CONFIG_WIRELESS;    __u8 wifi_acked_valid:1;    __u8 wifi_acked:1;#endif;    __u8 no_fcs:1;    __u8 encapsulation:1;    __u8 encap_hdr_csum:1;    __u8 csum_valid:1;#ifdef CONFIG_IPV6_NDISC_NODETYPE;    __u8 ndisc_nodetype:2;#endif;#if IS_ENABLED(CONFIG_IP_VS);    __u8 ipvs_property:1;#endif;#if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) || IS_ENABLED(CONFIG_NF_TABLES);    __u8 nf_trace:1;#endif;#ifdef CONFIG_NET_SWITCHDEV;    __u8 offload_fwd_mark:1;    __u8 offload_l3_fwd_mark:1;#endif;    __u8 redirected:1;#ifdef CONFIG_NET_REDIRECT;    __u8 from_ingress:1;#endif;#ifdef CONFIG_NETFILTER_SKIP_EGRESS;    __u8 nf_skip_egress:1;#endif;#ifdef CONFIG_SKB_DECRYPTED;    __u8 decrypted:1;#endif;    __u8 slow_gro:1;#if IS_ENABLED(CONFIG_IP_SCTP);    __u8 csum_not_inet:1;#endif;    __u8 unreadable:1;#if defined(CONFIG_NET_SCHED) || defined(CONFIG_NET_XGRESS);    __u16 tc_index;#endif;    u16 alloc_cpu;    union {        __wsum csum;        struct {            __u16 csum_start;            __u16 csum_offset;        };    };    __u32 priority;    int skb_iif;    __u32 hash;    union {        u32 vlan_all;        struct {            __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;#ifdef CONFIG_KCOV;    u64 kcov_handle;#endif;    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

(akadev) alternate use ofdev whendev would beNULL

rbnode

RB tree node, alternative to next/prev for netem/tcp

list

queue head

ll_node

anchor in an llist (eg socket defer_list)

sk

Socket we are owned by

{unnamed_union}

anonymous

tstamp

Time we arrived/left

skb_mstamp_ns

(akatstamp) earliest departure time; start pointfor 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)

_sk_redir

socket redirection information for skmsg

_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 beendone for it, don’t do them again

head_frag

skb was allocated from page fragments,not allocated bykmalloc() orvmalloc().

pfmemalloc

skbuff was allocated from PFMEMALLOC reserves

pp_recycle

mark the packet for recycling instead of freeing (impliespage_pool support on driver)

active_extensions

active extensions (skb_ext_id types)

pkt_type

Packet class

ignore_df

allow local fragmentation

dst_pending_confirm

need to confirm neighbour

ip_summed

Driver fed us an IP checksum

ooo_okay

allow the mapping of a socket to a queue to be changed

tstamp_type

When set, skb->tstamp has thedelivery_time clock base of skb->tstamp.

tc_at_ingress

used within tc_classify to distinguish in/egress

tc_skip_classify

do not classify packet. set by IFB device

remcsum_offload

remote checksum offload is enabled

csum_complete_sw

checksum was completed by software

csum_level

indicates the number of consecutive checksums found inthe packet minus one that have been verified asCHECKSUM_UNNECESSARY (max 3)

inner_protocol_type

whether the inner protocol isENCAP_TYPE_ETHER or ENCAP_TYPE_IPPROTO

l4_hash

indicate hash is a canonical 4-tuple hash over transportports.

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

ndisc_nodetype

router type (from link layer)

ipvs_property

skbuff is owned by ipvs

nf_trace

netfilter packet trace flag

offload_fwd_mark

Packet was L2-forwarded in hardware

offload_l3_fwd_mark

Packet was L3-forwarded in hardware

redirected

packet was redirected by packet classifier

from_ingress

packet was redirected from the ingress path

nf_skip_egress

packet shall skip nf egress - see netfilter_netdev.h

decrypted

Decrypted SKB

slow_gro

state present at GRO time, slower prepare step required

csum_not_inet

use CRC32c to resolve CHECKSUM_PARTIAL

unreadable

indicates that at least 1 of the fragments in this skb isunreadable.

tc_index

Traffic control index

alloc_cpu

CPU which did the skb allocation.

{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

{unnamed_union}

anonymous

vlan_all

vlan fields (proto & tci)

{unnamed_struct}

anonymous

vlan_proto

vlan encapsulation protocol

vlan_tci

vlan tag control information

{unnamed_union}

anonymous

napi_id

id of the NAPIstructthis skb came from

sender_cpu

(akanapi_id) source CPU in XPS

secmark

security marking

{unnamed_union}

anonymous

mark

Generic packet mark

reserved_tailroom

(akamark) number of bytes of free space availableat the tail of an sk_buff

{unnamed_union}

anonymous

inner_protocol

Protocol (encapsulation)

inner_ipproto

(akainner_protocol) stores ipproto whenskb->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

kcov_handle

KCOV remote handle for remote coverage collection

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

Parameters

conststructsk_buff*skb

buffer

Parameters

conststructsk_buff*skb

buffer

Return

skb dst_entry, regardless of reference taken or not.

Parameters

structsk_buff*skb

buffer

Description

Resets skb dst_entry without adjusting its reference count. Useful incases where dst_entry needs to be temporarily reset and restored.Note that the returned value cannot be used directly because itmight contain SKB_DST_NOREF bit.

When in doubt, preferskb_dst_drop() overskb_dstref_steal() to correctlyhandle dst_entry reference counting.

Return

original skb dst_entry.

Parameters

structsk_buff*skb

buffer

unsignedlongrefdst

dst entry from a call toskb_dstref_steal()

Parameters

structsk_buff*skb

buffer

structdst_entry*dst

dst entry

Description

Sets skb dst, assuming a reference was taken on dst and shouldbe released byskb_dst_drop()

Parameters

structsk_buff*skb

buffer

structdst_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_releasewill be avoided by refdst_drop. If dst entry is not cached, we takereference, so that last dst_release can destroy the dst immediately.

Parameters

conststructsk_buff*skb

buffer

Parameters

conststructsk_buff*skb

buffer

Parameters

structsk_buff*skb

buffer

Return

true if we can free the skb.

Parameters

structsk_buff*skb

buffer to free

Parameters

unsignedintsize

size to allocate

gfp_tpriority

allocation mask

Description

This function is a convenient wrapper around__alloc_skb().

Parameters

conststructsock*sk

socket

conststructsk_buff*skb

buffer

Return

true if skb is a fast clone, and its clone is not freed.Some drivers callskb_orphan() in theirndo_start_xmit(),so we also check that didn’t happen.

Parameters

unsignedintsize

size to allocate

gfp_tpriority

allocation mask

Description

This function is a convenient wrapper around__alloc_skb().

Parameters

structsk_buff*skb

buffer to pad

intpad

space to pad

Description

Ensure that a buffer is followed by a padding area that is zerofilled. Used by network drivers which may DMA or transfer databeyond the buffer end onto the wire.

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

Parameters

conststructsk_buff_head*list

queue head

Description

Returns true if the queue is empty, false otherwise.

Parameters

conststructsk_buff_head*list

queue head

Description

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

Parameters

conststructsk_buff_head*list

queue head

conststructsk_buff*skb

buffer

Description

Returns true ifskb is the last buffer on the list.

Parameters

conststructsk_buff_head*list

queue head

conststructsk_buff*skb

buffer

Description

Returns true ifskb is the first buffer on the list.

Parameters

conststructsk_buff_head*list

queue head

conststructsk_buff*skb

current buffer

Description

Return the next packet inlist afterskb. It is only valid tocall this ifskb_queue_is_last() evaluates to false.

Parameters

conststructsk_buff_head*list

queue head

conststructsk_buff*skb

current buffer

Description

Return the prev packet inlist beforeskb. It is only valid tocall this ifskb_queue_is_first() evaluates to false.

Parameters

structsk_buff*skb

buffer to reference

Description

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

Parameters

conststructsk_buff*skb

buffer to check

Description

Returns true if the buffer was generated withskb_clone() and isone of multiple shared copies of the buffer. Cloned buffers areshared data so must not be written to under normal circumstances.

Parameters

conststructsk_buff*skb

buffer to check

Description

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

Parameters

structsk_buff*skb

buffer to operate on

Description

See “DOC: dataref and headerless skbs”.

Parameters

conststructsk_buff*skb

buffer to check

Description

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

Parameters

structsk_buff*skb

buffer to check

gfp_tpri

priority for memory allocation

Description

If the buffer is shared the buffer is cloned and the old copydrops a reference. A new clone with a single reference is returned.If the buffer is not shared the original buffer is returned. Whenbeing called from interrupt status or with spinlocks held pri mustbe GFP_ATOMIC.

NULL is returned on a memory allocation failure.

Parameters

structsk_buff*skb

buffer to check

gfp_tpri

priority for memory allocation

Description

If the socket buffer is a clone then this function creates a newcopy of the data, drops a reference count on the old copy and returnsthe new copy with the reference count at 1. If the buffer is not a clonethe original buffer is returned. When called with a spinlock held orfrom interrupt statepri must beGFP_ATOMIC

NULL is returned on a memory allocation failure.

Parameters

conststructsk_buff_head*list_

list to peek at

Description

Peek ansk_buff. Unlike most other operations you _MUST_be careful with this one. A peek leaves the buffer on thelist and someone else may run off with it. You must holdthe appropriate locks or have a private queue to do this.

ReturnsNULL for an empty list or a pointer to the head element.The reference count is not incremented and the reference is thereforevolatile. Use with caution.

Parameters

conststructsk_buff_head*list_

list to peek at

Description

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

Parameters

structsk_buff*skb

skb to start from

conststructsk_buff_head*list_

list to peek at

Description

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

Parameters

conststructsk_buff_head*list_

list to peek at

Description

Peek ansk_buff. Unlike most other operations you _MUST_be careful with this one. A peek leaves the buffer on thelist and someone else may run off with it. You must holdthe appropriate locks or have a private queue to do this.

ReturnsNULL for an empty list or a pointer to the tail element.The reference count is not incremented and the reference is thereforevolatile. Use with caution.

Parameters

conststructsk_buff_head*list_

list to measure

Description

Return the length of ansk_buff queue.

Parameters

conststructsk_buff_head*list_

list to measure

Description

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

Parameters

structsk_buff_head*list

queue to initialize

Description

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

Parameters

conststructsk_buff_head*list

the new list to add

structsk_buff_head*head

the place to add it in the first list

Parameters

structsk_buff_head*list

the new list to add

structsk_buff_head*head

the place to add it in the first list

Description

The list atlist is reinitialised

Parameters

conststructsk_buff_head*list

the new list to add

structsk_buff_head*head

the place to add it in the first list

Parameters

structsk_buff_head*list

the new list to add

structsk_buff_head*head

the place to add it in the first list

Description

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

Parameters

structsk_buff_head*list

list to use

structsk_buff*prev

place after this buffer

structsk_buff*newsk

buffer to queue

Description

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

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

Parameters

structsk_buff_head*list

list to use

structsk_buff*newsk

buffer to queue

Description

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

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

Parameters

structsk_buff_head*list

list to use

structsk_buff*newsk

buffer to queue

Description

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

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

Parameters

structsk_buff_head*list

list to dequeue from

Description

Remove the head of the list. This function does not take any locksso must be used with appropriate locks held only. The head item isreturned orNULL if the list is empty.

Parameters

structsk_buff_head*list

list to dequeue from

Description

Remove the tail of the list. This function does not take any locksso must be used with appropriate locks held only. The tail item isreturned orNULL if the list is empty.

Parameters

structsk_buff*skb

buffer to add len to

intdelta

number of bytes to add

Parameters

structsk_buff*skb

buffer containing fragment to be initialised

inti

fragment index to initialise

netmem_refnetmem

the netmem to use for this fragment

intoff

the offset to the data withpage

intsize

the length of the data

Description

Initialises thei’th fragment ofskb to point tosize bytes atoffsetoff withinpage.

Does not take any additional reference on the fragment.

Parameters

structsk_buff*skb

buffer containing fragment to be initialised

inti

paged fragment index to initialise

structpage*page

the page to use for this fragment

intoff

the offset to the data withpage

intsize

the length of the data

Description

As per__skb_fill_page_desc() -- initialises thei’th fragment ofskb to point tosize bytes at offsetoff withinpage. Inaddition updatesskb such thati is the last fragment.

Does not take any additional reference on the fragment.

Parameters

structsk_buff*skb

buffer containing fragment to be initialised

inti

paged fragment index to initialise

structpage*page

the page to use for this fragment

intoff

the offset to the data withpage

intsize

the length of the data

Description

Variant ofskb_fill_page_desc() which does not deal withpfmemalloc, if page is not owned by us.

Parameters

conststructsk_buff*skb

buffer to check

Description

Return the number of bytes of free space at the head of ansk_buff.

Parameters

conststructsk_buff*skb

buffer to check

Description

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

Parameters

conststructsk_buff*skb

buffer to check

Description

Return the number of bytes of free space at the tail of an sk_buffallocated bysk_stream_alloc()

Parameters

structsk_buff*skb

buffer to alter

intlen

bytes to move

Description

Increase the headroom of an emptysk_buff by reducing the tailroom. This is only allowed for an empty buffer.

Parameters

structsk_buff*skb

buffer to alter

unsignedintmtu

maximum amount of headlen permitted

unsignedintneeded_tailroom

minimum amount of reserved_tailroom

Description

Set reserved_tailroom so that headlen can be as large as possible butnot larger than mtu and tailroom cannot be smaller thanneeded_tailroom.The required headroom should already have been reserved before usingthis function.

Parameters

structsk_buff*skb

buffer to alter

Description

Hardened version ofskb_reset_transport_header().

Return

true if the operation was a success.

Parameters

structsk_buff*skb

buffer to alter

unsignedintlen

new length

Description

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

Parameters

structsk_buff*skb

buffer to orphan

Description

If a buffer currently has an owner then we call the owner’sdestructor function and make theskb unowned. The buffer continuesto exist but is no longer charged to its former owner.

Parameters

structsk_buff*skb

buffer to orphan frags from

gfp_tgfp_mask

allocation mask for replacement pages

Description

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

Parameters

structsk_buff_head*list

list to empty

enumskb_drop_reasonreason

drop reason

Description

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

Parameters

unsignedintfragsz

fragment size

Description

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

Parameters

structnet_device*dev

network device to receive on

unsignedintlength

length to allocate

Description

Allocate a newsk_buff and assign it a usage count of one. Thebuffer has unspecified headroom built in. Users should allocatethe headroom they think they need without accounting for thebuilt in space. The built in space is used for optimisations.

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

Parameters

gfp_tgfp_mask

allocation priority. Set __GFP_NOMEMALLOC if not for network Rx

unsignedintorder

size of the allocation

Description

Allocate a new page.

NULL is returned if there is no free memory.

Parameters

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

Parameters

conststructpage*page

the page to test

Description

A page shouldn’t be considered for reusing/recycling if it was allocatedunder memory pressure or at a distant memory node.

Return

false if this page should be returned to page allocator, trueotherwise.

Parameters

conststructpage*page

The page that was allocated from skb_alloc_page

structsk_buff*skb

The skb that may need pfmemalloc set

Parameters

constskb_frag_t*frag

the paged fragment

Parameters

skb_frag_t*frag

skb fragment

intdelta

value to add

Parameters

skb_frag_t*frag

skb fragment

unsignedintoffset

offset of fragment

Parameters

skb_frag_t*fragto

skb fragment where offset is set

constskb_frag_t*fragfrom

skb fragment offset is copied from

Parameters

constskb_frag_t*frag

the fragment

Return

thestructnet_iov associated withfrag. Returns NULL if thisfrag has no associated net_iov.

Parameters

constskb_frag_t*frag

the paged fragment

Return

thestructpage associated withfrag. Returns NULL if this fraghas no associated page.

Parameters

constskb_frag_t*frag

the fragment

Return

thenetmem_ref associated withfrag.

Parameters

constskb_frag_t*frag

the paged fragment buffer

Return

the address of the data withinfrag. The page must alreadybe mapped.

Parameters

constskb_frag_t*frag

the paged fragment buffer

Return

the address of the data withinfrag. Checks that the pageis mapped and returnsNULL otherwise.

Parameters

skb_frag_t*fragto

skb fragment where page is set

constskb_frag_t*fragfrom

skb fragment page is copied from

Parameters

structdevice*dev

the device to map the fragment to

constskb_frag_t*frag

the paged fragment to map

size_toffset

the offset within the fragment (starting at thefragment’s own offset)

size_tsize

the number of bytes to map

enumdma_data_directiondir

the direction of the mapping (PCI_DMA_*)

Description

Maps the page associated withfrag todevice.

Parameters

conststructsk_buff*skb

buffer to check

unsignedintlen

length up to which to write

Description

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

Parameters

structsk_buff*skb

buffer to cow

unsignedintheadroom

needed headroom

Description

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

The result is skb with writable area skb->head...skb->tailand at leastheadroom of space at head.

Parameters

structsk_buff*skb

buffer to cow

unsignedintheadroom

needed headroom

Description

This function is identical to skb_cow except that we replace theskb_cloned check by skb_header_cloned. It should be used whenyou only need to push on some header and do not need to modifythe data.

Parameters

structsk_buff*skb

buffer to pad

unsignedintlen

minimal length

Description

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

Parameters

structsk_buff*skb

buffer to pad

unsignedintlen

minimal length

boolfree_on_error

free buffer on error

Description

Pads up a buffer to ensure the trailing bytes exist and areblanked. If the buffer already contains sufficient data itis untouched. Otherwise it is extended. Returns zero onsuccess. The skb is freed on error iffree_on_error is true.

Parameters

structsk_buff*skb

buffer to pad

unsignedintlen

minimal length

Description

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

Parameters

structsk_buff*skb

buffer to linarize

Description

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

Parameters

conststructsk_buff*skb

buffer to test

Return

true if the skb has at least one frag that might be modifiedby an external entity (as invmsplice()/sendfile())

Parameters

structsk_buff*skb

buffer to process

Description

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

Parameters

structsk_buff*skb

buffer to update

constvoid*start

start of data before pull

unsignedintlen

length of data pulled

Description

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

Parameters

structsk_buff*skb

buffer to update

constvoid*start

start of data after push

unsignedintlen

length of data pushed

Description

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

Parameters

structsk_buff*skb

buffer to update

unsignedintlen

length of data pulled

Description

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

Parameters

structsk_buff*skb

buffer to trim

unsignedintlen

new length

Description

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

Parameters

structsk_buff*skb

socket buffer to check

netdev_features_tfeatures

net device features

Description

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

Parameters

conststructsk_buff*skb

skb to get stamp from

struct__kernel_old_timeval*stamp

pointer tostruct__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 astructtimeval and storesit in stamp.

Parameters

structsk_buff*skb

packet to operate on

constintlen

number of bytes pushed or pulled fromsk_buff->data

constunsignedintn

number of bytes tomemmove() from pre-push/pullsk_buff->data

Description

Movesn bytes of packet data, can be zero, and all bytes of skb metadata.

Assumes metadata is located immediately beforesk_buff->data prior to thepush/pull, and that sufficient headroom exists to hold it after anskb_push(). Otherwise, metadata is cleared and a one-time warning is issued.

Preferskb_postpull_data_move() orskb_postpush_data_move() to calling thishelper directly.

Parameters

structsk_buff*skb

packet to operate on

constunsignedintlen

number of bytes pulled fromsk_buff->data

constunsignedintn

number of bytes tomemmove() from pre-pullsk_buff->data

Description

Seeskb_data_move() for details.

Parameters

structsk_buff*skb

packet to operate on

constunsignedintlen

number of bytes pushed ontosk_buff->data

constunsignedintn

number of bytes tomemmove() from pre-pushsk_buff->data

Description

Seeskb_data_move() for details.

Parameters

structsk_buff*skb

clone of the original outgoing packet

structskb_shared_hwtstamps*hwtstamps

hardware time stamps

Description

PHY drivers may accept clones of transmitted packets fortimestamping via their phy_driver.txtstamp method. These driversmust call this function to return the skb back to the stack with atimestamp.

Parameters

structsk_buff*orig_skb

the original outgoing packet

structskb_shared_hwtstamps*hwtstamps

hardware time stamps, may be NULL if not available

Description

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

Parameters

structsk_buff*skb

A socket buffer.

Description

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

Specifically, one should make absolutely sure that this function iscalled before TX completion of this packet can trigger. Otherwisethe packet could potentially already be freed.

Parameters

structsk_buff*skb

the original outgoing packet

boolacked

ack status

Parameters

structsk_buff*skb

packet to process

Description

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

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

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 todata to obtain extension address

chunks

size currently allocated, stored in SKB_EXT_ALIGN_SHIFT units

data

start of extension data, variable sized

Parameters

conststructsk_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 canuse this helper, to document places where we make this assertion.

Parameters

conststructsk_buff*skb

skb to check

Description

The head on skbs build around a head frag can be removed if they arenot cloned. This function returns true if the skb head is locked downdue to either being allocated via kmalloc, or by being a clone withmultiple references to the head.

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;    unsigned char           skc_bypass_prot_mem: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_SOCK_RX_QUEUE_MAPPING;    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 __u64unionofskc_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

__u32unionofskc_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_bypass_prot_mem

bypass the per-protocol memory accounting for skb

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_flagsSO_LINGER (l_onoff),SO_BROADCAST,SO_KEEPALIVE,SO_OOBINLINE settings,SO_TIMESTAMPING settings

skc_listener

connection request listener socket (aka rsk_listener)[unionwithskc_flags]

skc_tw_dr

(aka tw_dr) ptr tostructinet_timewait_death_row[unionwithskc_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)[unionwithskc_incoming_cpu]

skc_tw_rcv_nxt

(aka tw_rcv_nxt) TCP window next expected seq number[unionwithskc_incoming_cpu]

skc_refcnt

reference count

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_SOCK_RX_QUEUE_MAPPING;#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_bypass_prot_mem      __sk_common.skc_bypass_prot_mem;#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;    atomic_t sk_drops;    __s32 sk_peek_off;    struct sk_buff_head     sk_error_queue;    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;    struct dst_entry   *sk_rx_dst;    int sk_rx_dst_ifindex;    u32 sk_rx_dst_cookie;#ifdef CONFIG_NET_RX_BUSY_POLL;    unsigned int            sk_ll_usec;    unsigned int            sk_napi_id;    u16 sk_busy_poll_budget;    u8 sk_prefer_busy_poll;#endif;    u8 sk_userlocks;    int sk_rcvbuf;    struct sk_filter   *sk_filter;    union {        struct socket_wq   *sk_wq;    };    void (*sk_data_ready)(struct sock *sk);    long sk_rcvtimeo;    int sk_rcvlowat;    int sk_err;    struct socket           *sk_socket;#ifdef CONFIG_MEMCG;    struct mem_cgroup       *sk_memcg;#endif;#ifdef CONFIG_XFRM;    struct xfrm_policy  *sk_policy[2];#endif;#if IS_ENABLED(CONFIG_INET_PSP);    struct psp_assoc   *psp_assoc;#endif;    socket_lock_t sk_lock;    u32 sk_reserved_mem;    int sk_forward_alloc;    u32 sk_tsflags;    int sk_write_pending;    atomic_t sk_omem_alloc;    int sk_err_soft;    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_head     sk_write_queue;    struct page_frag        sk_frag;    union {        struct timer_list       sk_timer;        struct timer_list       tcp_retransmit_timer;        struct timer_list       mptcp_retransmit_timer;    };    unsigned long           sk_pacing_rate;    atomic_t sk_zckey;    atomic_t sk_tskey;    unsigned long           sk_tx_queue_mapping_jiffies;    u32 sk_dst_pending_confirm;    u32 sk_pacing_status;    unsigned long           sk_max_pacing_rate;    long sk_sndtimeo;    u32 sk_priority;    u32 sk_mark;    kuid_t sk_uid;    u16 sk_protocol;    u16 sk_type;    struct dst_entry   *sk_dst_cache;    netdev_features_t sk_route_caps;#ifdef CONFIG_SOCK_VALIDATE_XMIT;    struct sk_buff*         (*sk_validate_xmit_skb)(struct sock *sk, struct net_device *dev, struct sk_buff *skb);#endif;    u16 sk_gso_type;    u16 sk_gso_max_segs;    unsigned int            sk_gso_max_size;    gfp_t sk_allocation;    u32 sk_txhash;    int sk_sndbuf;    u8 sk_pacing_shift;    bool sk_use_task_frag;    u8 sk_gso_disabled : 1, sk_kern_sock : 1, sk_no_check_tx : 1, sk_no_check_rx : 1;    u8 sk_shutdown;    unsigned long           sk_lingertime;    struct proto            *sk_prot_creator;    rwlock_t sk_callback_lock;    u32 sk_ack_backlog;    u32 sk_max_ack_backlog;    unsigned long           sk_ino;    spinlock_t sk_peer_lock;    int sk_bind_phc;    struct pid              *sk_peer_pid;    const struct cred       *sk_peer_cred;    ktime_t sk_stamp;#if BITS_PER_LONG==32;    seqlock_t sk_stamp_seq;#endif;    int sk_disconnects;    union {        u8 sk_txrehash;        u8 sk_scm_recv_flags;        struct {            u8 sk_scm_credentials : 1, sk_scm_security : 1, sk_scm_pidfd : 1, sk_scm_rights : 1, sk_scm_unused : 4;        };    };    u8 sk_clockid;    u8 sk_txtime_deadline_mode : 1, sk_txtime_report_errors : 1, sk_txtime_unused : 6;#define SK_BPF_CB_FLAG_TEST(SK, FLAG) ((SK)->sk_bpf_cb_flags & (FLAG));    u8 sk_bpf_cb_flags;    void *sk_user_data;#ifdef CONFIG_SECURITY;    void *sk_security;#endif;    struct sock_cgroup_data sk_cgrp_data;    void (*sk_state_change)(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      *sk_reuseport_cb;#ifdef CONFIG_BPF_SYSCALL;    struct bpf_local_storage   *sk_bpf_storage;#endif;    struct numa_drop_counters *sk_drop_counters;    struct rcu_head         sk_rcu;    netns_tracker ns_tracker;    struct xarray           sk_user_frags;#if IS_ENABLED(CONFIG_PROVE_LOCKING) && IS_ENABLED(CONFIG_MODULES);    struct module           *sk_owner;#endif;};

Members

__sk_common

shared layout with inet_timewait_sock

sk_drops

raw/udp drops counter

sk_peek_off

current peek_offset value

sk_error_queue

rarely used

sk_receive_queue

incoming packets

sk_backlog

always used with the per-socket spinlock held

sk_rx_dst

receive input route used by early demux

sk_rx_dst_ifindex

ifindex forsk_rx_dst

sk_rx_dst_cookie

cookie forsk_rx_dst

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_busy_poll_budget

napi processing budget when busypolling

sk_prefer_busy_poll

prefer busypolling over softirq processing

sk_userlocks

SO_SNDBUF andSO_RCVBUF settings

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_data_ready

callback to indicate there is data to be processed

sk_rcvtimeo

SO_RCVTIMEO setting

sk_rcvlowat

SO_RCVLOWAT setting

sk_err

last error

sk_socket

Identd and reporting IO signals

sk_memcg

this socket’s memory cgroup association

sk_policy

flow policy

psp_assoc

PSP association, if socket is PSP-secured

sk_lock

synchronizer

sk_reserved_mem

space reserved and non-reclaimable for the socket

sk_forward_alloc

space allocated forward

sk_tsflags

SO_TIMESTAMPING flags

sk_write_pending

a write to stream socket waits to start

sk_omem_alloc

“o” is “option” or “other”

sk_err_soft

errors that don’t cause failure but are the cause of apersistent failure not just ‘timed out’

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 [unionwithsk_send_head]

sk_write_queue

Packet sending queue

sk_frag

cached page frag

{unnamed_union}

anonymous

sk_timer

sock cleanup timer

tcp_retransmit_timer

tcp retransmit timer

mptcp_retransmit_timer

mptcp retransmit timer

sk_pacing_rate

Pacing rate (if supported by transport/packet scheduler)

sk_zckey

counter to order MSG_ZEROCOPY notifications

sk_tskey

counter to disambiguate concurrent tstamp requests

sk_tx_queue_mapping_jiffies

time in jiffies of lastsk_tx_queue_mapping refresh.

sk_dst_pending_confirm

need to confirm neighbour

sk_pacing_status

Pacing status (requested, handled by sch_fq)

sk_max_pacing_rate

Maximum pacing rate (SO_MAX_PACING_RATE)

sk_sndtimeo

SO_SNDTIMEO setting

sk_priority

SO_PRIORITY setting

sk_mark

generic packet mark

sk_uid

user id of owner

sk_protocol

which protocol this socket belongs in this network family

sk_type

socket type (SOCK_STREAM, etc)

sk_dst_cache

destination cache

sk_route_caps

route capabilities (e.g.NETIF_F_TSO)

sk_validate_xmit_skb

ptr to an optional validate function

sk_gso_type

GSO type (e.g.SKB_GSO_TCPV4)

sk_gso_max_segs

Maximum number of GSO segments

sk_gso_max_size

Maximum GSO segment size to build

sk_allocation

allocation mode

sk_txhash

computed flow hash for use on transmit

sk_sndbuf

size of send buffer in bytes

sk_pacing_shift

scaling factor for TCP Small Queues

sk_use_task_frag

allowsk_page_frag() to use current->task_frag.Sockets that can be used under memory reclaim shouldset this to false.

sk_gso_disabled

if set, NETIF_F_GSO_MASK is forbidden.

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_shutdown

mask ofSEND_SHUTDOWN and/orRCV_SHUTDOWN

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_ack_backlog

current listen backlog

sk_max_ack_backlog

listen backlog set inlisten()

sk_ino

inode number (zero if orphaned)

sk_peer_lock

lock protectingsk_peer_pid andsk_peer_cred

sk_bind_phc

SO_TIMESTAMPING bind PHC index of PTP virtual clockfor timestamping

sk_peer_pid

structpid for this socket’s peer

sk_peer_cred

SO_PEERCRED setting

sk_stamp

time stamp of last packet received

sk_stamp_seq

lock for accessing sk_stamp on 32 bit architectures only

sk_disconnects

number of disconnect operations performed on this sock

{unnamed_union}

anonymous

sk_txrehash

enable TX hash rethink

sk_scm_recv_flags

all flags used byscm_recv()

{unnamed_struct}

anonymous

sk_scm_credentials

flagged by SO_PASSCRED to recv SCM_CREDENTIALS

sk_scm_security

flagged by SO_PASSSEC to recv SCM_SECURITY

sk_scm_pidfd

flagged by SO_PASSPIDFD to recv SCM_PIDFD

sk_scm_rights

flagged by SO_PASSRIGHTS to recv SCM_RIGHTS

sk_scm_unused

unused flags forscm_recv()

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_bpf_cb_flags

used inbpf_setsockopt()

sk_user_data

RPC layer private data. Write-protected bysk_callback_lock.

sk_security

used by security modules

sk_cgrp_data

cgroup data for this cgroup

sk_state_change

callback to indicate change in the state of the sock

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_bpf_storage

ptr to cache and control for bpf_sk_storage

sk_drop_counters

optional pointer to numa_drop_counters

sk_rcu

used during RCU grace period

ns_tracker

tracker for netns reference

sk_user_frags

xarray of pages the user is holding a reference on.

sk_owner

reference to the real owner of the socket that callssock_lock_init_class_and_name().

Parameters

conststructsock*sk

socket

Parameters

conststructsock*sk

socket

uintptr_tflags

flag bits

Description

The caller must be holding sk->sk_callback_lock.

Parameters

conststructsock*sk

socket

uintptr_tflags

flag bits

Parameters

tpos

the type * to use as a loop cursor.

pos

thestructhlist_node to use as a loop cursor.

head

the head for your list.

offset

offset of hlist_node within the struct.

Parameters

structsock*sk

socket

Description

This version should be used for very small section, where process won’t blockreturn 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

Parameters

structsock*sk

socket

boolslow

slow mode

Description

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

Parameters

conststructsock*sk

socket

Return

sk_wmem_alloc minus initial offset of one

Parameters

conststructsock*sk

socket

Return

sk_rmem_alloc

Parameters

conststructsock*sk

socket

Return