Linux 網路和網路裝置 API¶

Linux 網路¶

網路基本型別¶

enum sock_type¶: 套接字型別

常量

SOCK_STREAM: 流（連線）套接字
SOCK_DGRAM: 資料報（無連線）套接字
SOCK_RAW: 原始套接字
SOCK_RDM: 可靠傳遞訊息
SOCK_SEQPACKET: 順序資料包套接字
SOCK_DCCP: 資料報擁塞控制協議套接字
SOCK_PACKET: 在開發級別獲取資料包的 Linux 特定方法。用於在使用者級別編寫 rarp 和其他類似內容。

描述

新增一些新的套接字型別時，請 grep ARCH_HAS_SOCKET_TYPE include/asm-* /socket.h，至少 MIPS 會因二進位制相容性原因而覆蓋此列舉。

enum sock_shutdown_cmd¶: 關閉型別

常量

SHUT_RD: 關閉接收
SHUT_WR: 關閉傳輸
SHUT_RDWR: 關閉接收/傳輸

struct socket¶: 通用 BSD 套接字

定義:

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;
};

成員

狀態: 套接字狀態 (SS_CONNECTED 等)
型別: 套接字型別 (SOCK_STREAM 等)
標誌: 套接字標誌 (SOCK_NOSPACE 等)
檔案: 用於垃圾回收的檔案後向指標
sk: 內部網路協議不可知套接字表示
ops: 協議特定的套接字操作
wq: 用於多種用途的等待佇列

套接字緩衝區函式¶

unsigned int skb_frag_size(const skb_frag_t *frag)¶: 返回 skb 片段的大小

引數

const skb_frag_t *frag: skb 片段

void skb_frag_size_set(skb_frag_t *frag, unsigned int size)¶: 設定 skb 片段的大小

引數

skb_frag_t *frag: skb 片段
unsigned int size: 片段大小

void skb_frag_size_add(skb_frag_t *frag, int delta)¶: 將 skb 片段的大小增加 delta

引數

skb_frag_t *frag: skb 片段
int delta: 要新增的值

void skb_frag_size_sub(skb_frag_t *frag, int delta)¶: 將 skb 片段的大小減少 delta

引數

skb_frag_t *frag: skb 片段
int delta: 要減去的值

bool skb_frag_must_loop(struct page *p)¶: 測試 p 是否為高記憶體頁

引數

struct page *p: 片段的頁

skb_frag_foreach_page¶

skb_frag_foreach_page (f, f_off, f_len, p, p_off, p_len, copied)

迴圈訪問片段中的頁

引數

f

要操作的 skb 片段

f_off

從 f->netmem 開始的偏移量

f_len

從 f_off 開始迴圈的長度

p

（臨時變數）當前頁

p_off

（臨時變數）從當前頁的開頭開始的偏移量，僅在第一頁上非零。

p_len

（臨時變數）當前頁中的長度，僅在第一頁和最後一頁上 < PAGE_SIZE。

copied

（臨時變數）到目前為止的長度，不包括當前的 p_len。

片段可以儲存一個複合頁，在這種情況下，必須對每個常規頁呼叫每頁操作，特別是 kmap_atomic。

struct skb_shared_hwtstamps¶: 硬體時間戳

定義:

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

成員

{unnamed_union}: 匿名
hwtstamp: 硬體時間戳轉換為自任意時間點以來的持續時間
netdev_data: 網路裝置驅動程式的地址/Cookie，用作實際硬體時間戳的參考

描述

由 ktime_get_real() 生成的軟體時間戳儲存在 skb->tstamp 中。

hwtstamps 只能與來自同一裝置的其他 hwtstamps 進行比較。

此結構作為 skb_shared_info 的一部分附加到資料包。使用 skb_hwtstamps() 獲取指標。

struct sk_buff¶: 套接字緩衝區

定義:

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;
};

成員

{unnamed_union}: 匿名
{unnamed_struct}: 匿名
next: 列表中的下一個緩衝區
prev: 列表中的上一個緩衝區
{unnamed_union}: 匿名
dev: 我們到達/離開的裝置
dev_scratch: （又名 dev）當 dev 為 NULL 時，dev 的替代用法
rbnode: RB 樹節點，是 netem/tcp 的 next/prev 的替代方案
list: 佇列頭
ll_node: llist 中的錨點（例如套接字 defer_list）
sk: sk
{unnamed_union}: 匿名
我們擁有的套接字: tstamp
我們到達/離開的時間: skb_mstamp_ns
（又名 tstamp）最早的離開時間；重傳計時器的起點: cb
{unnamed_union}: 匿名
{unnamed_struct}: 匿名
控制緩衝區。每個層都可以免費使用。將私有變數放在此處: _skb_refdst
目標條目（帶有 norefcount 位）: destructor
解構函式: tcp_tsorted_anchor
TCP 的列表結構 (tp->tsorted_sent_queue): _sk_redir
skmsg 的套接字重定向資訊: _nfct
關聯的連線（如果有）（帶有 nfctinfo 位）: len
實際資料的長度: data_len
資料長度: mac_len
鏈路層標頭的長度: hdr_len
克隆 skb 的可寫標頭長度: queue_mapping
多佇列裝置的佇列對映: cloned
頭部可能被克隆（檢查 refcnt 以確保）: nohdr
僅有效負載引用，不得修改標頭: fclone
skbuff 克隆狀態: peeked
此資料包已被看到，因此已完成其統計，請勿再次執行: head_frag
skb 是從頁面片段分配的，而不是由 kmalloc() 或 vmalloc() 分配的。: pfmemalloc
skbuff 是從 PFMEMALLOC 保留區分配的: pp_recycle
標記資料包以進行回收而不是釋放（意味著驅動程式上支援 page_pool）: active_extensions
活動擴充套件（skb_ext_id 型別）: pkt_type
資料包類: ignore_df
允許本地分片: dst_pending_confirm
需要確認鄰居: ip_summed
驅動程式向我們提供了 IP 校驗和: ooo_okay
允許更改套接字到佇列的對映: tstamp_type
設定後，skb->tstamp 具有 skb->tstamp 的 delivery_time 時鐘基準。: tc_at_ingress
在 tc_classify 中用於區分入口/出口: tc_skip_classify
不分類資料包。由 IFB 裝置設定: remcsum_offload
已啟用遠端校驗和解除安裝: csum_complete_sw
校驗和已由軟體完成: csum_level
指示資料包中找到的連續校驗和的數量減一，這些校驗和已驗證為 CHECKSUM_UNNECESSARY（最大 3 個）: inner_protocol_type
內部協議是 ENCAP_TYPE_ETHER 還是 ENCAP_TYPE_IPPROTO: l4_hash
指示雜湊是傳輸埠上的規範 4 元組雜湊。: sw_hash
指示雜湊是在軟體堆疊中計算的: wifi_acked_valid
wifi_acked 已設定: wifi_acked
幀是否在 wifi 上被確認: no_fcs
請求 NIC 將最後 4 個位元組視為乙太網 FCS: encapsulation
指示 skbuff 中的內部標頭有效: encap_hdr_csum
需要軟體校驗和: csum_valid
校驗和已有效: ndisc_nodetype
路由器型別（來自鏈路層）: ipvs_property
skbuff 由 ipvs 擁有: nf_trace
netfilter 資料包跟蹤標誌: offload_fwd_mark
資料包已在硬體中進行 L2 轉發: offload_l3_fwd_mark
資料包已在硬體中進行 L3 轉發: redirected
資料包已被資料包分類器重定向: from_ingress
資料包已從入口路徑重定向: nf_skip_egress
資料包應跳過 nf 出口 - 請參閱 netfilter_netdev.h: decrypted
已解密的 SKB: slow_gro
GRO 時存在的狀態，需要更慢的準備步驟: csum_not_inet
使用 CRC32c 解析 CHECKSUM_PARTIAL: unreadable
指示此 skb 中至少有 1 個片段不可讀。: tc_index
流量控制索引: alloc_cpu
{unnamed_union}: 匿名
執行 skb 分配的 CPU。: csum
{unnamed_struct}: 匿名
校驗和（必須包括開始/偏移量對）: csum_start
應從 skb->head 開始校驗和的偏移量: csum_offset
應儲存校驗和的從 csum_start 開始的偏移量: priority
資料包排隊優先順序: skb_iif
我們到達的裝置的 ifindex: hash
{unnamed_union}: 匿名
資料包雜湊: vlan_all
{unnamed_struct}: 匿名
vlan 欄位（proto & tci）: vlan_proto
vlan 封裝協議: vlan_tci
{unnamed_union}: 匿名
vlan 標記控制資訊: napi_id
此 skb 來自的 NAPI 結構的 ID: sender_cpu
（又名 napi_id）XPS 中的源 CPU: secmark
{unnamed_union}: 匿名
安全標記: mark
通用資料包標記: reserved_tailroom
{unnamed_union}: 匿名
（又名 mark）sk_buff 尾部可用的空閒空間位元組數: inner_protocol
協議（封裝）: inner_ipproto
（又名 inner_protocol）當 skb->inner_protocol_type == ENCAP_TYPE_IPPROTO 時儲存 ipproto；: inner_transport_header
內部傳輸層標頭（封裝）: inner_network_header
網路層標頭（封裝）: inner_mac_header
鏈路層標頭（封裝）: protocol
來自驅動程式的資料包協議: transport_header
傳輸層標頭: network_header
網路層標頭: mac_header
鏈路層標頭: kcov_handle
KCOV 遠端覆蓋收集控制代碼: tail
尾指標: end
結束指標: head
緩衝區頭: data
資料頭指標: truesize
緩衝區大小: users
使用者計數 - 請參閱 {datagram,tcp}.c: extensions

已分配的擴充套件，如果 active_extensions 非零，則有效: bool skb_pfmemalloc(const struct sk_buff *skb)¶

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: const struct sk_buff *skb

緩衝區: struct dst_entry *skb_dst(const struct sk_buff *skb)¶

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: const struct sk_buff *skb

返回 skb dst_entry

返回

skb dst_entry，無論是否獲取了引用。: void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)¶

引數

設定 skb dst: const struct sk_buff *skb
struct sk_buff *skb: struct dst_entry *dst

描述

dst 條目

設定 skb dst，假設在 dst 上獲取了引用，應由 skb_dst_drop() 釋放: void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)¶

引數

設定 skb dst: const struct sk_buff *skb
struct sk_buff *skb: struct dst_entry *dst

描述

設定 skb dst，希望不獲取引用

設定 skb dst，假設未在 dst 上獲取引用。如果 dst 條目已快取，我們不會獲取引用，並且 refdst_drop 將避免 dst_release。如果 dst 條目未快取，我們會獲取引用，以便最後一個 dst_release 可以立即銷燬 dst。: bool skb_dst_is_noref(const struct sk_buff *skb)¶

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: const struct sk_buff *skb

測試 skb dst 是否未引用計數: unsigned int skb_napi_id(const struct sk_buff *skb)¶

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: const struct sk_buff *skb

返回 skb 的 NAPI ID: bool skb_unref(struct sk_buff *skb)¶

引數

設定 skb dst: const struct sk_buff *skb

返回 skb dst_entry

減少 skb 的引用計數

如果我們能釋放 skb，則為 true。: void kfree_skb(struct sk_buff *skb)¶

引數

設定 skb dst: 釋放具有“NOT_SPECIFIED”原因的 sk_buff

要釋放的緩衝區: struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)¶

引數

unsigned int size: 分配網路緩衝區
要分配的大小: gfp_t priority

描述

分配掩碼

此函式是 __alloc_skb() 周圍的便捷包裝器。: bool skb_fclone_busy(const struct sock *sk, const struct sk_buff *skb)¶

引數

檢查 fclone 是否繁忙: const struct sock *sk
測試 skb 是否從 PFMEMALLOC 保留區分配: const struct sk_buff *skb

返回 skb dst_entry

套接字

如果 skb 是快速克隆，並且其克隆未被釋放，則為 true。一些驅動程式在其 ndo_start_xmit() 中呼叫 skb_orphan()，因此我們還要檢查是否發生了這種情況。: struct sk_buff *alloc_skb_fclone(unsigned int size, gfp_t priority)¶

引數

unsigned int size: 分配網路緩衝區
要分配的大小: gfp_t priority

描述

分配掩碼

從 fclone 快取分配網路緩衝區: int skb_pad(struct sk_buff *skb, int pad)¶

引數

設定 skb dst

將 skb 的尾部填充為零

要填充的緩衝區

int pad

要填充的空間

確保緩衝區後面跟著一個零填充的填充區域。由可能將資料 DMA 或傳輸到線上的超出緩衝區末端的網路驅動程式使用。

在記憶體不足的情況下可能返回錯誤。 skb 會在出錯時釋放。: int skb_queue_empty(const struct sk_buff_head *list)¶

引數

檢查佇列是否為空

佇列頭

const struct sk_buff_head *list

如果佇列為空，則返回 true，否則返回 false。: int skb_queue_empty(const struct sk_buff_head *list)¶

引數

檢查佇列是否為空

佇列頭

bool skb_queue_empty_lockless(const struct sk_buff_head *list)¶

如果佇列為空，則返回 true，否則返回 false。此變體可以在無鎖上下文中使用。: bool skb_queue_is_last(const struct sk_buff_head *list, const struct sk_buff *skb)¶

引數

檢查佇列是否為空

佇列頭

測試 skb 是否從 PFMEMALLOC 保留區分配

const struct sk_buff *skb

檢查 skb 是否為佇列中的最後一個條目

如果 skb 是列表中的最後一個緩衝區，則返回 true。: bool skb_queue_is_first(const struct sk_buff_head *list, const struct sk_buff *skb)¶

引數

檢查佇列是否為空

佇列頭

測試 skb 是否從 PFMEMALLOC 保留區分配

const struct sk_buff *skb

檢查 skb 是否為佇列中的第一個條目

如果 skb 是列表中的第一個緩衝區，則返回 true。: struct sk_buff *skb_queue_next(const struct sk_buff_head *list, const struct sk_buff *skb)¶

引數

檢查佇列是否為空

佇列頭

測試 skb 是否從 PFMEMALLOC 保留區分配

返回佇列中的下一個資料包

當前緩衝區

返回 skb 之後 list 中的下一個資料包。僅當 skb_queue_is_last() 評估為 false 時呼叫此函式才有效。: struct sk_buff *skb_queue_prev(const struct sk_buff_head *list, const struct sk_buff *skb)¶

引數

檢查佇列是否為空

佇列頭

測試 skb 是否從 PFMEMALLOC 保留區分配

返回佇列中的下一個資料包

返回佇列中的上一個資料包

返回 skb 之前 list 中的上一個資料包。僅當 skb_queue_is_first() 評估為 false 時呼叫此函式才有效。: struct sk_buff *skb_get(struct sk_buff *skb)¶

引數

設定 skb dst

引用緩衝區

再次引用套接字緩衝區並返回指向該緩衝區的指標。

int skb_cloned(const struct sk_buff *skb)¶: 緩衝區是否為克隆

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

如果緩衝區是使用 skb_clone() 生成的，並且是緩衝區的多個共享副本之一，則返回 true。克隆緩衝區是共享資料，因此在正常情況下不得寫入。

int skb_header_cloned(const struct sk_buff *skb)¶: 標頭是否為克隆

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

如果修改緩衝區的標頭部分需要複製資料，則返回 true。

void __skb_header_release(struct sk_buff *skb)¶: 允許克隆使用 headroom

引數

設定 skb dst: 要操作的緩衝區

描述

參見“DOC: dataref and headerless skbs”。

int skb_shared(const struct sk_buff *skb)¶: 緩衝區是否共享

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

如果有多個人引用此緩衝區，則返回 true。

struct sk_buff *skb_share_check(struct sk_buff *skb, gfp_t pri)¶: 檢查緩衝區是否共享，如果共享則克隆它

引數

設定 skb dst

要檢查的緩衝區

gfp_t pri

記憶體分配的優先順序

如果緩衝區被共享，則緩衝區將被克隆，舊副本將減少一個引用。將返回一個具有單個引用的新克隆。如果緩衝區未被共享，則將返回原始緩衝區。當從中斷狀態呼叫或持有自旋鎖時，pri 必須為 GFP_ATOMIC。

記憶體分配失敗時返回 NULL。

struct sk_buff *skb_unshare(struct sk_buff *skb, gfp_t pri)¶: 建立共享緩衝區的副本

引數

設定 skb dst

要檢查的緩衝區

gfp_t pri

記憶體分配的優先順序

如果套接字緩衝區是克隆，則此函式將建立資料的新副本，減少舊副本上的引用計數，並返回引用計數為 1 的新副本。如果緩衝區不是克隆，則將返回原始緩衝區。當使用自旋鎖或從中斷狀態呼叫時，pri 必須為 GFP_ATOMIC

記憶體分配失敗時返回 NULL。

struct sk_buff *skb_peek(const struct sk_buff_head *list_)¶: 檢視 sk_buff_head 的頭部

引數

const struct sk_buff_head *list_

要檢視的列表

檢視 sk_buff。與大多數其他操作不同，您_必須_小心處理此操作。檢視會將緩衝區留在列表上，其他人可能會將其取走。您必須持有適當的鎖或擁有私有佇列才能執行此操作。

對於空列表返回 NULL，對於頭部元素返回指標。引用計數不會遞增，因此引用是易失的。請謹慎使用。

struct sk_buff *__skb_peek(const struct sk_buff_head *list_)¶: 檢視非空的 sk_buff_head 的頭部

引數

const struct sk_buff_head *list_

要檢視的列表

與 skb_peek() 類似，但呼叫者知道列表不為空。

struct sk_buff *skb_peek_next(struct sk_buff *skb, const struct sk_buff_head *list_)¶: 從佇列中檢視給定 skb 之後的 skb

引數

設定 skb dst

從 skb 開始

const struct sk_buff_head *list_

要檢視的列表

當遇到列表末尾時返回 NULL，對於下一個元素返回指標。引用計數不會遞增，因此引用是易失的。請謹慎使用。

struct sk_buff *skb_peek_tail(const struct sk_buff_head *list_)¶: 檢視 sk_buff_head 的尾部

引數

const struct sk_buff_head *list_

要檢視的列表

檢視 sk_buff。與大多數其他操作不同，您_必須_小心處理此操作。檢視會將緩衝區留在列表上，其他人可能會將其取走。您必須持有適當的鎖或擁有私有佇列才能執行此操作。

對於空列表返回 NULL，對於尾部元素返回指標。引用計數不會遞增，因此引用是易失的。請謹慎使用。

__u32 skb_queue_len(const struct sk_buff_head *list_)¶: 獲取佇列長度

引數

const struct sk_buff_head *list_

要測量的列表

返回 sk_buff 佇列的長度。

__u32 skb_queue_len_lockless(const struct sk_buff_head *list_)¶: 獲取佇列長度

引數

const struct sk_buff_head *list_

要測量的列表

返回 sk_buff 佇列的長度。此變體可以在無鎖上下文中使用。

void __skb_queue_head_init(struct sk_buff_head *list)¶: 初始化 sk_buff_head 的非自旋鎖部分

引數

struct sk_buff_head *list

要初始化的佇列

這僅初始化 sk_buff_head 物件的列表和佇列長度方面。這允許初始化 sk_buff_head 的列表方面，而無需重新初始化諸如自旋鎖之類的內容。它也可以用於堆疊上的 sk_buff_head 物件，其中已知不使用自旋鎖。

void skb_queue_splice(const struct sk_buff_head *list, struct sk_buff_head *head)¶: 連線兩個 skb 列表，這是為堆疊設計的

引數

檢查佇列是否為空: 要新增的新列表
struct sk_buff_head *head: 在第一個列表中新增它的位置

void skb_queue_splice_init(struct sk_buff_head *list, struct sk_buff_head *head)¶: 連線兩個 skb 列表並重新初始化空列表

引數

struct sk_buff_head *list

要新增的新列表

struct sk_buff_head *head

在第一個列表中新增它的位置

重新初始化 list 處的列表

void skb_queue_splice_tail(const struct sk_buff_head *list, struct sk_buff_head *head)¶: 連線兩個 skb 列表，每個列表都是一個佇列

引數

檢查佇列是否為空: 要新增的新列表
struct sk_buff_head *head: 在第一個列表中新增它的位置

void skb_queue_splice_tail_init(struct sk_buff_head *list, struct sk_buff_head *head)¶: 連線兩個 skb 列表並重新初始化空列表

引數

struct sk_buff_head *list

要新增的新列表

struct sk_buff_head *head

在第一個列表中新增它的位置

每個列表都是一個佇列。重新初始化 list 處的列表

void __skb_queue_after(struct sk_buff_head *list, struct sk_buff *prev, struct sk_buff *newsk)¶: 在列表頭部排隊緩衝區

引數

struct sk_buff_head *list

要使用的列表

struct sk_buff *prev

在此緩衝區之後放置

struct sk_buff *newsk

要排隊的緩衝區

在列表的中間對緩衝區進行排隊。此函式不採用任何鎖，因此在呼叫它之前必須持有所需的鎖。

一個緩衝區不能同時放置在兩個列表上。

void __skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)¶: 在列表頭部排隊緩衝區

引數

struct sk_buff_head *list

要使用的列表

struct sk_buff *newsk

要排隊的緩衝區

在列表的開頭排隊緩衝區。此函式不採用任何鎖，因此在呼叫它之前必須持有所需的鎖。

一個緩衝區不能同時放置在兩個列表上。

void __skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)¶: 在列表尾部排隊緩衝區

引數

struct sk_buff_head *list

要使用的列表

struct sk_buff *newsk

要排隊的緩衝區

在列表的末尾排隊緩衝區。此函式不採用任何鎖，因此在呼叫它之前必須持有所需的鎖。

一個緩衝區不能同時放置在兩個列表上。

struct sk_buff *__skb_dequeue(struct sk_buff_head *list)¶: 從佇列的頭部移除

引數

struct sk_buff_head *list

要從中出隊的列表

移除列表的頭部。此函式不採用任何鎖，因此必須僅在持有適當的鎖的情況下使用。返回頭部項，如果列表為空，則返回 NULL。

struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)¶: 從佇列的尾部移除

引數

struct sk_buff_head *list

要從中出隊的列表

移除列表的尾部。此函式不採用任何鎖，因此必須僅在持有適當的鎖的情況下使用。返回尾部項，如果列表為空，則返回 NULL。

void skb_len_add(struct sk_buff *skb, int delta)¶: 將一個數字新增到 skb 的 len 欄位

引數

設定 skb dst: 要新增 len 的緩衝區
int delta: 要新增的位元組數

void __skb_fill_netmem_desc(struct sk_buff *skb, int i, netmem_ref netmem, int off, int size)¶: 在 skb 中初始化一個片段

引數

設定 skb dst: 包含要初始化的片段的緩衝區
int i: 要初始化的片段索引
netmem_ref netmem: 用於此片段的 netmem
int off: 使用 page 的資料偏移量
int size: 資料的長度

描述

初始化 skb 的第 i 個片段，以指向 page 中偏移量 off 處的 size 位元組。

不會對片段進行任何額外的引用。

void skb_fill_page_desc(struct sk_buff *skb, int i, struct page *page, int off, int size)¶: 在 skb 中初始化分頁片段

引數

設定 skb dst: 包含要初始化的片段的緩衝區
int i: 要初始化的分頁片段索引
struct page *page: 用於此片段的頁面
int off: 使用 page 的資料偏移量
int size: 資料的長度

描述

與 __skb_fill_page_desc() 類似 - 初始化 skb 的第 i 個片段，以指向 page 中偏移量 off 處的 size 位元組。此外，更新 skb，使 i 成為最後一個片段。

不會對片段進行任何額外的引用。

void skb_fill_page_desc_noacc(struct sk_buff *skb, int i, struct page *page, int off, int size)¶: 在 skb 中初始化分頁片段

引數

設定 skb dst: 包含要初始化的片段的緩衝區
int i: 要初始化的分頁片段索引
struct page *page: 用於此片段的頁面
int off: 使用 page 的資料偏移量
int size: 資料的長度

描述

如果頁面不屬於我們，則 skb_fill_page_desc() 的變體不處理 pfmemalloc。

unsigned int skb_headroom(const struct sk_buff *skb)¶: 緩衝區頭部的位元組數

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

返回 sk_buff 頭部處的空閒空間位元組數。

int skb_tailroom(const struct sk_buff *skb)¶: 緩衝區末尾的位元組數

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

返回 sk_buff 尾部的空閒空間位元組數

int skb_availroom(const struct sk_buff *skb)¶: 緩衝區末尾的位元組數

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

返回由 sk_stream_alloc() 分配的 sk_buff 尾部的空閒空間位元組數

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

引數

設定 skb dst

要更改的緩衝區

int len

要移動的位元組數

透過減少尾部空間來增加空 sk_buff 的 headroom。這僅允許用於空緩衝區。

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

引數

設定 skb dst

要更改的緩衝區

unsigned int mtu

允許的最大 headlen

unsigned int needed_tailroom

reserved_tailroom 的最小量

設定 reserved_tailroom，以便 headlen 可以儘可能大，但不大於 mtu，並且 tailroom 不能小於 needed_tailroom。在使用此函式之前，應已預留所需的 headroom。

void pskb_trim_unique(struct sk_buff *skb, unsigned int len)¶: 從分頁的唯一（未克隆）緩衝區中移除末尾

引數

設定 skb dst

要更改的緩衝區

unsigned int len

新長度

這與 pskb_trim 相同，只是呼叫者知道 skb 未被克隆，因此我們永遠不會因記憶體不足而出現錯誤。

void skb_orphan(struct sk_buff *skb)¶: 孤立緩衝區

引數

設定 skb dst

要孤立的緩衝區

如果緩衝區當前有一個所有者，那麼我們呼叫所有者的解構函式，並使 skb 無所有者。緩衝區繼續存在，但不再向其前所有者收費。

int skb_orphan_frags(struct sk_buff *skb, gfp_t gfp_mask)¶: 孤立緩衝區中包含的 frags

引數

設定 skb dst

從中孤立 frags 的緩衝區

gfp_t gfp_mask

替換頁面的分配掩碼

對於 SKB 中每個需要解構函式的 frag（即有一個所有者），建立該 frag 的副本，並透過呼叫解構函式來釋放原始頁面。

void __skb_queue_purge_reason(struct sk_buff_head *list, enum skb_drop_reason reason)¶: 清空列表

引數

struct sk_buff_head *list

要清空的列表

enum skb_drop_reason reason

丟棄原因

刪除 sk_buff 列表上的所有緩衝區。每個緩衝區都會從列表中移除，並且引用計數會減 1。此函式不獲取列表鎖，呼叫者必須持有相關的鎖才能使用它。

void *netdev_alloc_frag(unsigned int fragsz)¶: 分配一個頁面片段

引數

unsigned int fragsz: 片段大小

描述

從頁面中為接收緩衝區分配一個片段。使用 GFP_ATOMIC 分配。

struct sk_buff *netdev_alloc_skb(struct net_device *dev, unsigned int length)¶: 在特定裝置上為 rx 分配一個 skbuff

引數

struct net_device *dev

要接收的網路裝置

unsigned int length

要分配的長度

分配一個新的 sk_buff，併為其分配一個使用計數為 1。該緩衝區內建了未指定的頭部空間。使用者應該分配他們認為需要的頭部空間，而無需考慮內建空間。內建空間用於最佳化。

如果沒有空閒記憶體，則返回 NULL。雖然此函式會分配記憶體，但可以從中斷中呼叫。

struct page *__dev_alloc_pages(gfp_t gfp_mask, unsigned int order)¶: 為網路 Rx 分配頁面

引數

gfp_t gfp_mask: 分配優先順序。如果不是用於網路 Rx，則設定 __GFP_NOMEMALLOC
unsigned int order: 分配的大小

描述

分配一個新頁面。

如果沒有空閒記憶體，則返回 NULL。

struct page *__dev_alloc_page(gfp_t gfp_mask)¶: 為網路 Rx 分配一個頁面

引數

gfp_t gfp_mask: 分配優先順序。如果不是用於網路 Rx，則設定 __GFP_NOMEMALLOC

描述

分配一個新頁面。

如果沒有空閒記憶體，則返回 NULL。

bool dev_page_is_reusable(const struct page *page)¶: 檢查頁面是否可以重用於網路 Rx

引數

const struct page *page: 要測試的頁面

描述

如果頁面是在記憶體壓力下或在遙遠的記憶體節點上分配的，則不應考慮重用/回收該頁面。

返回 skb dst_entry

如果應將此頁面返回給頁面分配器，則為 false；否則為 true。

void skb_propagate_pfmemalloc(const struct page *page, struct sk_buff *skb)¶: 如果在 RX 頁面之後分配 skb，則傳播 pfmemalloc

引數

const struct page *page: 從 skb_alloc_page 分配的頁面
設定 skb dst: 可能需要設定 pfmemalloc 的 skb

unsigned int skb_frag_off(const skb_frag_t *frag)¶: 返回 skb 片段的偏移量

引數

const skb_frag_t *frag: 分頁片段

void skb_frag_off_add(skb_frag_t *frag, int delta)¶: 將 skb 片段的偏移量增加 delta

引數

skb_frag_t *frag: skb 片段
int delta: 要新增的值

void skb_frag_off_set(skb_frag_t *frag, unsigned int offset)¶: 設定 skb 片段的偏移量

引數

skb_frag_t *frag: skb 片段
unsigned int offset: 片段的偏移量

void skb_frag_off_copy(skb_frag_t *fragto, const skb_frag_t *fragfrom)¶: 從另一個片段設定 skb 片段的偏移量

引數

skb_frag_t *fragto: 設定偏移量的 skb 片段
const skb_frag_t *fragfrom: 從中複製 skb 片段偏移量

struct net_iov *skb_frag_net_iov(const skb_frag_t *frag)¶: 檢索片段引用的 net_iov

引數

const skb_frag_t *frag: 片段

返回 skb dst_entry

與 frag 關聯的 struct net_iov。如果此片段沒有關聯的 net_iov，則返回 NULL。

struct page *skb_frag_page(const skb_frag_t *frag)¶: 檢索分頁片段引用的頁面

引數

const skb_frag_t *frag: 分頁片段

返回 skb dst_entry

與 frag 關聯的 struct page。如果此片段沒有關聯的頁面，則返回 NULL。

netmem_ref skb_frag_netmem(const skb_frag_t *frag)¶: 檢索片段引用的 netmem

引數

const skb_frag_t *frag: 片段

返回 skb dst_entry

與 frag 關聯的 netmem_ref。

void *skb_frag_address(const skb_frag_t *frag)¶: 獲取分頁片段中包含的資料的地址

引數

const skb_frag_t *frag: 分頁片段緩衝區

返回 skb dst_entry

frag 中資料的地址。必須已對映該頁面。

void *skb_frag_address_safe(const skb_frag_t *frag)¶: 獲取分頁片段中包含的資料的地址

引數

const skb_frag_t *frag: 分頁片段緩衝區

返回 skb dst_entry

frag 中資料的地址。檢查頁面是否已對映，否則返回 NULL。

void skb_frag_page_copy(skb_frag_t *fragto, const skb_frag_t *fragfrom)¶: 從另一個片段設定片段中的頁面

引數

skb_frag_t *fragto: 設定頁面的 skb 片段
const skb_frag_t *fragfrom: 從中複製 skb 片段頁面

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)¶: 透過 DMA API 對映分頁片段

引數

struct device *dev: 要將片段對映到的裝置
const skb_frag_t *frag: 要對映的分頁片段
size_t offset: 片段中的偏移量（從片段自己的偏移量開始）
size_t size: 要對映的位元組數
enum dma_data_direction dir: 對映的方向 (PCI_DMA_*)

描述

將與 frag 關聯的頁面對映到 device。

int skb_clone_writable(const struct sk_buff *skb, unsigned int len)¶: 克隆的標頭是否可寫

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要檢查的緩衝區

unsigned int len

要寫入的長度

如果修改克隆緩衝區標頭部分不需要複製資料，則返回 true。

int skb_cow(struct sk_buff *skb, unsigned int headroom)¶: 需要時複製 skb 的標頭

引數

設定 skb dst

要 cow 的緩衝區

unsigned int headroom

所需的頭部空間

如果傳遞的 skb 缺少足夠的頭部空間或其資料部分是共享的，則會重新分配資料。如果重新分配失敗，則返回錯誤，並且原始 skb 不會更改。

結果是 skb 具有可寫區域 skb->head...skb->tail，並且頭部至少有 headroom 的空間。

int skb_cow_head(struct sk_buff *skb, unsigned int headroom)¶: skb_cow 但只使頭部可寫

引數

設定 skb dst

要 cow 的緩衝區

unsigned int headroom

所需的頭部空間

此函式與 skb_cow 相同，只不過我們將 skb_cloned 檢查替換為 skb_header_cloned。當您只需要推送一些標頭而不需要修改資料時，應使用此函式。

int skb_padto(struct sk_buff *skb, unsigned int len)¶: 將 skbuff 填充到最小大小

引數

設定 skb dst

將 skb 的尾部填充為零

unsigned int len

最小長度

填充緩衝區以確保尾隨位元組存在並且為空白。如果緩衝區已經包含足夠的資料，則不會觸及。否則會擴充套件它。成功時返回零。錯誤時會釋放 skb。

int __skb_put_padto(struct sk_buff *skb, unsigned int len, bool free_on_error)¶: 增加大小並將 skbuff 填充到最小大小

引數

設定 skb dst

將 skb 的尾部填充為零

unsigned int len

最小長度

bool free_on_error

錯誤時釋放緩衝區

填充緩衝區以確保尾隨位元組存在並且為空白。如果緩衝區已經包含足夠的資料，則不會觸及。否則會擴充套件它。成功時返回零。如果 free_on_error 為 true，則在錯誤時釋放 skb。

int skb_put_padto(struct sk_buff *skb, unsigned int len)¶: 增加大小並將 skbuff 填充到最小大小

引數

設定 skb dst

將 skb 的尾部填充為零

unsigned int len

最小長度

填充緩衝區以確保尾隨位元組存在並且為空白。如果緩衝區已經包含足夠的資料，則不會觸及。否則會擴充套件它。成功時返回零。錯誤時會釋放 skb。

int skb_linearize(struct sk_buff *skb)¶: 將分頁 skb 轉換為線性 skb

引數

設定 skb dst

要線性的緩衝區

如果沒有空閒記憶體，則返回 -ENOMEM，否則返回零並釋放舊的 skb 資料。

bool skb_has_shared_frag(const struct sk_buff *skb)¶: 任何片段都可以被覆蓋嗎？

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要測試的緩衝區

返回 skb dst_entry

如果 skb 至少有一個可能被外部實體修改的片段（如 vmsplice()/sendfile() 中），則為 true

int skb_linearize_cow(struct sk_buff *skb)¶: 確保 skb 是線性和可寫的

引數

設定 skb dst

要處理的緩衝區

如果沒有空閒記憶體，則返回 -ENOMEM，否則返回零並釋放舊的 skb 資料。

void skb_postpull_rcsum(struct sk_buff *skb, const void *start, unsigned int len)¶: 在 pull 後更新接收 skb 的校驗和

引數

設定 skb dst

要更新的緩衝區

const void *start

pull 前的資料開始

unsigned int len

pull 的資料長度

在對接收的資料包執行 pull 操作後，您需要呼叫此函式來更新 CHECKSUM_COMPLETE 校驗和，或者將 ip_summed 設定為 CHECKSUM_NONE，以便可以從頭開始重新計算它。

void skb_postpush_rcsum(struct sk_buff *skb, const void *start, unsigned int len)¶: 在 push 後更新接收 skb 的校驗和

引數

設定 skb dst

要更新的緩衝區

const void *start

push 後的資料開始

unsigned int len

push 的資料長度

在對接收的資料包執行 push 操作後，您需要呼叫此函式來更新 CHECKSUM_COMPLETE 校驗和。

void *skb_push_rcsum(struct sk_buff *skb, unsigned int len)¶: push skb 並更新接收校驗和

引數

設定 skb dst

要更新的緩衝區

unsigned int len

pull 的資料長度

此函式對資料包執行 skb_push 操作，並更新 CHECKSUM_COMPLETE 校驗和。除非您知道校驗和差異為零（例如，有效的 IP 標頭），否則應在接收路徑處理中使用此函式代替 skb_push，或者您將 ip_summed 設定為 CHECKSUM_NONE。

int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)¶: trim 接收的 skb 並更新校驗和

引數

設定 skb dst

要 trim 的緩衝區

unsigned int len

新長度

這與 pskb_trim 完全相同，只不過它確保了接收的資料包的校驗和在操作後仍然有效。它可以更改 skb 指標。

bool skb_needs_linearize(struct sk_buff *skb, netdev_features_t features)¶: 檢查是否需要根據給定的裝置功能線性化給定的 skb。

引數

設定 skb dst

要檢查的套接字緩衝區

netdev_features_t features

網路裝置功能

如果以下任一條件為真，則返回 true：1. skb 具有 frag_list 並且裝置不支援 FRAGLIST，或者 2. skb 已分段並且裝置不支援 SG。

void skb_get_timestamp(const struct sk_buff *skb, struct __kernel_old_timeval *stamp)¶: 從 skb 獲取時間戳

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

從中獲取時間戳的 skb

struct __kernel_old_timeval *stamp

指向用於儲存時間戳的 struct __kernel_old_timeval 的指標

時間戳以 skb 中的偏移量儲存到基本時間戳。此函式將偏移量轉換回 struct timeval 並將其儲存在 stamp 中。

void skb_complete_tx_timestamp(struct sk_buff *skb, struct skb_shared_hwtstamps *hwtstamps)¶: 傳遞帶有 tx 時間戳的克隆 skb

引數

設定 skb dst: 原始傳出資料包的克隆
struct skb_shared_hwtstamps *hwtstamps: 硬體時間戳

描述

PHY 驅動程式可能會接受已傳輸資料包的克隆，以便透過其 phy_driver.txtstamp 方法進行時間戳。這些驅動程式必須呼叫此函式以將 skb 返回到具有時間戳的堆疊。

void skb_tstamp_tx(struct sk_buff *orig_skb, struct skb_shared_hwtstamps *hwtstamps)¶: 佇列克隆 skb 並帶有傳送時間戳

引數

struct sk_buff *orig_skb: 原始傳出資料包
struct skb_shared_hwtstamps *hwtstamps: 硬體時間戳，如果不可用，則可能為 NULL

描述

如果 skb 關聯了一個套接字，則此函式克隆 skb（從而共享實際資料和可選結構），儲存可選的硬體時間戳資訊（如果非 NULL）或生成軟體時間戳（否則），然後將克隆排隊到套接字的錯誤佇列。錯誤將被忽略。

void skb_tx_timestamp(struct sk_buff *skb)¶: 用於傳輸時間戳的驅動程式掛鉤

引數

設定 skb dst: 一個套接字緩衝區。

描述

乙太網 MAC 驅動程式應在其 hard_xmit() 函式中，在將 sk_buff 提供給 MAC 硬體之前立即呼叫此函式。

具體來說，應絕對確保在此資料包的 TX 完成可以觸發之前呼叫此函式。否則，資料包可能已被釋放。

void skb_complete_wifi_ack(struct sk_buff *skb, bool acked)¶: 傳送具有 wifi 狀態的 skb

引數

設定 skb dst: 原始傳出資料包
bool acked: 確認狀態

__sum16 skb_checksum_complete(struct sk_buff *skb)¶: 計算整個資料包的校驗和

引數

設定 skb dst

要處理的資料包

此函式計算整個資料包的校驗和加上 skb->csum 的值。後者可用於提供 TCP/UDP 使用的偽標頭的校驗和。它返回校驗和。

對於包含完整校驗和的協議，例如 ICMP/TCP/UDP，此函式可用於驗證接收資料包上的校驗和。在這種情況下，如果校驗和正確，該函式應返回零。特別是，如果 skb->ip_summed 是 CHECKSUM_UNNECESSARY，則此函式將返回零，這表示硬體已驗證了校驗和的正確性。

struct skb_ext¶: sk_buff 擴充套件

定義:

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

成員

refcnt: 分配時為 1，0 時取消分配
offset: 新增到 data 的偏移量以獲取擴充套件地址
chunks: 當前分配的大小，以 SKB_EXT_ALIGN_SHIFT 單位儲存
緩衝區頭: 擴充套件資料的開始，可變大小

注意

偏移量/長度以 8 位元組塊儲存，這允許: 使用“u8”型別，同時允許最多 2kb 的擴充套件資料。

void skb_checksum_none_assert(const struct sk_buff *skb)¶: 確保 skb ip_summed 為 CHECKSUM_NONE

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要檢查的 skb

描述

新的 skb 的 ip_summed 設定為 CHECKSUM_NONE。我們可以使用這個助手來記錄我們做出此斷言的地方，而不是強制 ip_summed 為 CHECKSUM_NONE。

bool skb_head_is_locked(const struct sk_buff *skb)¶: 確定 skb->head 是否已鎖定

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要檢查的 skb

描述

如果 skb 沒有被克隆，則圍繞 head frag 構建的 skb 的 head 可以被移除。如果 skb head 由於透過 kmalloc 分配或由於是克隆且對 head 有多個引用而被鎖定，則此函式返回 true。

struct sock_common¶: 套接字的最小網路層表示

定義:

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

成員

{unnamed_union}

匿名

skc_addrpair

8 位元組對齊的 skc_daddr & skc_rcv_saddr 的 __u64 聯合

{unnamed_struct}

匿名

skc_daddr

外部 IPv4 地址

skc_rcv_saddr

繫結本地 IPv4 地址

{unnamed_union}

匿名

skc_hash

用於各種協議查詢表的雜湊值

skc_u16hashes

UDP 查詢表使用的兩個 u16 雜湊值

{unnamed_union}

匿名

skc_portpair

skc_dport & skc_num 的 __u32 聯合

{unnamed_struct}

匿名

skc_dport

inet_dport/tw_dport 的佔位符

skc_num

inet_num/tw_num 的佔位符

skc_family

網路地址族

skc_state

連線狀態

skc_reuse

SO_REUSEADDR 設定

skc_reuseport

SO_REUSEPORT 設定

skc_ipv6only

套接字僅限 IPV6

skc_net_refcnt

套接字正在使用網路引用計數

skc_bound_dev_if

如果 != 0，則繫結裝置索引

{unnamed_union}

匿名

skc_bind_node

各種協議查詢表的繫結雜湊連結

skc_portaddr_node

UDP/UDP-Lite 協議的第二個雜湊連結

skc_prot

網路族內的協議處理程式

skc_net

對此套接字的網路名稱空間的引用

skc_v6_daddr

IPV6 目標地址

skc_v6_rcv_saddr

IPV6 源地址

skc_cookie

套接字的 cookie 值

{unnamed_union}

匿名

skc_flags

sk_flags 的佔位符 SO_LINGER (l_onoff)、SO_BROADCAST、SO_KEEPALIVE、SO_OOBINLINE 設定、SO_TIMESTAMPING 設定

skc_listener

連線請求偵聽器套接字（也稱為 rsk_listener）[與 skc_flags 的聯合]

skc_tw_dr

（也稱為 tw_dr）指向 struct inet_timewait_death_row 的指標 [與 skc_flags 的聯合]

{unnamed_union}

匿名

skc_node

各種協議查詢表的主雜湊連結

skc_nulls_node

TCP/UDP/UDP-Lite 協議的主雜湊連結

skc_tx_queue_mapping

此連線的 tx 佇列號

skc_rx_queue_mapping

此連線的 rx 佇列號

{unnamed_union}

匿名

skc_incoming_cpu

記錄/匹配處理傳入資料包的 cpu

skc_rcv_wnd

（也稱為 rsk_rcv_wnd）TCP 接收視窗大小（可能已縮放）[與 skc_incoming_cpu 的聯合]

skc_tw_rcv_nxt

（也稱為 tw_rcv_nxt）TCP 視窗下一個預期序列號 [與 skc_incoming_cpu 的聯合]

skc_refcnt

引用計數

這是套接字的最小網路層表示，struct sock 和 struct inet_timewait_sock 的標頭。

struct sock¶: 套接字的網路層表示

定義:

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_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;
    __cacheline_group_begin(sock_write_rx);
    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;
    __cacheline_group_end(sock_write_rx);
    __cacheline_group_begin(sock_read_rx);
    struct dst_entry __rcu  *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 __rcu  *sk_filter;
    union {
        struct socket_wq __rcu  *sk_wq;
    };
    void (*sk_data_ready)(struct sock *sk);
    long sk_rcvtimeo;
    int sk_rcvlowat;
    __cacheline_group_end(sock_read_rx);
    __cacheline_group_begin(sock_read_rxtx);
    int sk_err;
    struct socket           *sk_socket;
    struct mem_cgroup       *sk_memcg;
#ifdef CONFIG_XFRM;
    struct xfrm_policy __rcu *sk_policy[2];
#endif;
    __cacheline_group_end(sock_read_rxtx);
    __cacheline_group_begin(sock_write_rxtx);
    socket_lock_t sk_lock;
    u32 sk_reserved_mem;
    int sk_forward_alloc;
    u32 sk_tsflags;
    __cacheline_group_end(sock_write_rxtx);
    __cacheline_group_begin(sock_write_tx);
    int sk_write_pending;
    atomic_t sk_omem_alloc;
    int sk_sndbuf;
    int sk_wmem_queued;
    refcount_t sk_wmem_alloc;
    unsigned long           sk_tsq_flags;
    union {
        struct sk_buff  *sk_send_head;
        struct rb_root  tcp_rtx_queue;
    };
    struct sk_buff_head     sk_write_queue;
    u32 sk_dst_pending_confirm;
    u32 sk_pacing_status;
    struct page_frag        sk_frag;
    struct timer_list       sk_timer;
    unsigned long           sk_pacing_rate;
    atomic_t sk_zckey;
    atomic_t sk_tskey;
    __cacheline_group_end(sock_write_tx);
    __cacheline_group_begin(sock_read_tx);
    unsigned long           sk_max_pacing_rate;
    long sk_sndtimeo;
    u32 sk_priority;
    u32 sk_mark;
    struct dst_entry __rcu  *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;
    u8 sk_pacing_shift;
    bool sk_use_task_frag;
    __cacheline_group_end(sock_read_tx);
    u8 sk_gso_disabled : 1,sk_kern_sock : 1,sk_no_check_tx : 1, sk_no_check_rx : 1;
    u8 sk_shutdown;
    u16 sk_type;
    u16 sk_protocol;
    unsigned long           sk_lingertime;
    struct proto            *sk_prot_creator;
    rwlock_t sk_callback_lock;
    int sk_err_soft;
    u32 sk_ack_backlog;
    u32 sk_max_ack_backlog;
    kuid_t sk_uid;
    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 __rcu     *sk_reuseport_cb;
#ifdef CONFIG_BPF_SYSCALL;
    struct bpf_local_storage __rcu  *sk_bpf_storage;
#endif;
    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;
};

成員

__sk_common: 與 inet_timewait_sock 的共享佈局
sk_drops: 原始/udp 丟棄計數器
sk_peek_off: 當前 peek_offset 值
sk_error_queue: 很少使用
sk_receive_queue: 傳入資料包
sk_backlog: 始終與每個套接字自旋鎖一起使用
sk_rx_dst: 早期多路分解使用的接收輸入路由
sk_rx_dst_ifindex: sk_rx_dst 的 ifindex
sk_rx_dst_cookie: sk_rx_dst 的 cookie
sk_ll_usec: 沒有資料時 busy_poll 的微秒數
sk_napi_id: 最後接收 sk 資料的 napi 上下文的 ID
sk_busy_poll_budget: busy_polling 時的 napi 處理預算
sk_prefer_busy_poll: 首選 busy_polling 而不是 softirq 處理
sk_userlocks: SO_SNDBUF 和 SO_RCVBUF 設定
sk_rcvbuf: 以位元組為單位的接收緩衝區大小
sk_filter: 套接字過濾指令
{unnamed_union}: 匿名
sk_wq: 套接字等待佇列和非同步標頭
sk_data_ready: 指示有資料要處理的回撥
sk_rcvtimeo: SO_RCVTIMEO 設定
sk_rcvlowat: SO_RCVLOWAT 設定
sk_err: 上次錯誤
sk_socket: Identd 和報告 IO 訊號
sk_memcg: 此套接字的記憶體 cgroup 關聯
sk_policy: 流策略
sk_lock: 同步器
sk_reserved_mem: 為套接字保留且不可回收的空間
sk_forward_alloc: 向前分配的空間
sk_tsflags: SO_TIMESTAMPING 標誌
sk_write_pending: 流套接字的寫入等待開始
sk_omem_alloc: “o”是“選項”或“其他”
sk_sndbuf: 以位元組為單位的傳送緩衝區大小
sk_wmem_queued: 持久佇列大小
sk_wmem_alloc: 提交的傳輸佇列位元組
sk_tsq_flags: TCP 小佇列標誌
{unnamed_union}: 匿名
sk_send_head: 要傳輸的內容的前端
tcp_rtx_queue: TCP 重傳佇列 [與 sk_send_head 的聯合]
sk_write_queue: 資料包傳送佇列
sk_dst_pending_confirm: dst_pending_confirm
sk_pacing_status: 步調狀態（已請求，由 sch_fq 處理）
sk_frag: 快取的頁面 frag
sk_timer: 套接字清理計時器
sk_pacing_rate: 步調速率（如果傳輸/資料包排程程式支援）
sk_zckey: 用於對 MSG_ZEROCOPY 通知進行排序的計數器
sk_tskey: 用於消除併發 tstamp 請求歧義的計數器
sk_max_pacing_rate: 最大步調速率 (SO_MAX_PACING_RATE)
sk_sndtimeo: SO_SNDTIMEO 設定
sk_priority: SO_PRIORITY 設定
sk_mark: 通用資料包標記
sk_dst_cache: 目標快取
sk_route_caps: 路由功能（例如 NETIF_F_TSO）
sk_validate_xmit_skb: 指向可選驗證函式的指標
sk_gso_type: GSO 型別（例如 SKB_GSO_TCPV4）
sk_gso_max_segs: GSO 段的最大數量
sk_gso_max_size: 要構建的最大 GSO 段大小
sk_allocation: 分配模式
sk_txhash: 計算出的流雜湊，用於傳輸
sk_pacing_shift: TCP 小佇列的縮放因子
sk_use_task_frag: 允許 sk_page_frag() 使用 current->task_frag。可以在記憶體回收下使用的套接字應將其設定為 false。
sk_gso_disabled: 如果設定，則禁止 NETIF_F_GSO_MASK。
sk_kern_sock: 如果 sock 正在使用核心鎖定類，則為 True
sk_no_check_tx: SO_NO_CHECK 設定，在 TX 資料包中設定校驗和
sk_no_check_rx: 允許在 RX 資料包中使用零校驗和
sk_shutdown: SEND_SHUTDOWN 和/或 RCV_SHUTDOWN 的掩碼
sk_type: 套接字型別 (SOCK_STREAM 等)
sk_protocol: 此套接字屬於此網路族中的哪個協議
sk_lingertime: SO_LINGER l_linger 設定
sk_prot_creator: 原始 sock 建立者的 sk_prot（例如，請參閱 ipv6_setsockopt，IPV6_ADDRFORM）
sk_callback_lock: 與此結構末尾的回撥一起使用
sk_err_soft: 不會導致失敗但會導致持久失敗的錯誤，不僅僅是“超時”
sk_ack_backlog: 當前偵聽積壓
sk_max_ack_backlog: 在 listen() 中設定的偵聽積壓
sk_uid: 所有者的使用者 ID
sk_peer_lock: 保護 sk_peer_pid 和 sk_peer_cred 的鎖
sk_bind_phc: SO_TIMESTAMPING 繫結 PTP 虛擬時鐘的 PHC 索引以進行時間戳
sk_peer_pid: 此套接字的對等方的 struct pid
sk_peer_cred: SO_PEERCRED 設定
sk_stamp: 上次接收的資料包的時間戳
sk_stamp_seq: 僅在 32 位體系結構上用於訪問 sk_stamp 的鎖
sk_disconnects: 在此 sock 上執行的斷開連線操作的數量
{unnamed_union}: 匿名
sk_txrehash: 啟用 TX 雜湊重新思考
sk_scm_recv_flags: scm_recv() 使用的所有標誌
{unnamed_struct}: 匿名
sk_scm_credentials: 由 SO_PASSCRED 標記以接收 SCM_CREDENTIALS
sk_scm_security: 由 SO_PASSSEC 標記以接收 SCM_SECURITY
sk_scm_pidfd: 由 SO_PASSPIDFD 標記以接收 SCM_PIDFD
sk_scm_rights: 由 SO_PASSRIGHTS 標記以接收 SCM_RIGHTS
sk_scm_unused: scm_recv() 的未使用標誌
sk_clockid: 基於時間的排程使用的 clockid (SO_TXTIME)
sk_txtime_deadline_mode: 設定 SO_TXTIME 的截止時間模式
sk_txtime_report_errors: 設定 SO_TXTIME 的報告錯誤模式
sk_txtime_unused: 未使用的 txtime 標誌
sk_bpf_cb_flags: 在 bpf_setsockopt() 中使用
sk_user_data: RPC 層私有資料。受 sk_callback_lock 的防寫。
sk_security: 由安全模組使用
sk_cgrp_data: 此 cgroup 的 cgroup 資料
sk_state_change: 回撥以指示 sock 狀態的更改
sk_write_space: 回撥以指示有 bf 傳送空間可用
sk_error_report: 回撥以指示錯誤（例如 MSG_ERRQUEUE）
sk_backlog_rcv: 回撥以處理積壓
sk_destruct: 在套接字釋放時呼叫，即當所有 refcnt == 0 時
sk_reuseport_cb: reuseport 組容器
sk_bpf_storage: 指向 bpf_sk_storage 的快取和控制元件的指標
sk_rcu: 在 RCU 寬限期內使用
ns_tracker: netns 引用的跟蹤器
sk_user_frags: 使用者持有引用的頁面的 xarray。
sk_owner: 對呼叫 sock_lock_init_class_and_name() 的套接字的實際所有者的引用。

bool sk_user_data_is_nocopy(const struct sock *sk)¶: 測試是否不得複製 sk_user_data 指標

引數

檢查 fclone 是否繁忙: const struct sock *sk

void *__locked_read_sk_user_data_with_flags(const struct sock *sk, uintptr_t flags)¶: 僅當 sk_user_data 中已設定所有引數標誌時才返回指標。否則返回 NULL

引數

檢查 fclone 是否繁忙: const struct sock *sk
uintptr_t flags: 標誌位

描述

呼叫者必須持有 sk->sk_callback_lock。

void *__rcu_dereference_sk_user_data_with_flags(const struct sock *sk, uintptr_t flags)¶: 僅當 sk_user_data 中已設定所有引數標誌時才返回指標。否則返回 NULL

引數

檢查 fclone 是否繁忙: const struct sock *sk
uintptr_t flags: 標誌位

sk_for_each_entry_offset_rcu¶

sk_for_each_entry_offset_rcu (tpos, pos, head, offset)

在給定結構偏移處迭代列表

引數

tpos: 用作迴圈游標的 type *。
pos: 用作迴圈游標的 struct hlist_node。
結束指標: 列表的 head。
offset: struct 中 hlist_node 的偏移量。

bool lock_sock_fast(struct sock *sk)¶: lock_sock 的快速版本

引數

struct sock *sk: const struct sock *sk

描述

此版本應用於非常小的部分，如果採取快速路徑，則程序不會阻止返回 false

sk_lock.slock 已鎖定，owned = 0，BH 已停用

如果採取慢速路徑，則返回 true

sk_lock.slock 已解鎖，owned = 1，BH 已啟用

void unlock_sock_fast(struct sock *sk, bool slow)¶: lock_sock_fast 的補充

引數

struct sock *sk: const struct sock *sk
bool slow: 慢速模式

描述

用於使用者上下文的快速解鎖套接字。如果啟用了慢速模式，我們將呼叫常規的 release_sock()

int sk_wmem_alloc_get(const struct sock *sk)¶: 返回寫入分配

引數

檢查 fclone 是否繁忙: const struct sock *sk

返回 skb dst_entry

sk_wmem_alloc 減去 1 的初始偏移量

int sk_rmem_alloc_get(const struct sock *sk)¶: 返回讀取分配

引數

檢查 fclone 是否繁忙: const struct sock *sk

返回 skb dst_entry

sk_rmem_alloc

bool sk_has_allocations(const struct sock *sk)¶: 檢查是否已進行分配

引數

檢查 fclone 是否繁忙: const struct sock *sk

返回 skb dst_entry

如果套接字具有寫入或讀取分配，則為 true

bool skwq_has_sleeper(struct socket_wq *wq)¶: 檢查是否有任何等待程序

引數

struct socket_wq *wq: struct socket_wq

返回 skb dst_entry

如果 socket_wq 具有等待程序，則為 true

描述

skwq_has_sleeper 和 sock_poll_wait 的目的是包裝記憶體屏障呼叫。新增它們的原因是 tcp 程式碼中發現的競爭。

考慮以下 tcp 程式碼路徑

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

當 CPU1 所做的 __add_wait_queue 更改保留在其快取中時，以及 CPU2 端的 tp->rcv_nxt 更新時，會觸發 tcp 競爭。如果套接字上沒有更多資料，則 CPU1 最終可能會呼叫計劃程式並永遠休眠。

void sock_poll_wait(struct file *filp, struct socket *sock, poll_table *p)¶: poll_wait 呼叫的包裝器。

引數

struct file *filp: 檔案
struct socket *sock: 要等待的套接字
poll_table *p: poll_table

描述

請參閱 wq_has_sleeper 函式中的註釋。

struct page_frag *sk_page_frag(struct sock *sk)¶: 返回適當的 page_frag

引數

struct sock *sk: const struct sock *sk

描述

當知道我們處於程序上下文中並且擁有與 current 關聯的所有內容時，使用每個任務的 page_frag 而不是每個套接字的 page_frag 以進行最佳化。

直接回收和頁面錯誤都可以巢狀在其他套接字操作中，並最終遞迴到 sk_page_frag()，而它已經在使用中：當用戶停用 sk_use_task_frag 時，顯式避免任務頁面 frag。

返回 skb dst_entry

如果上下文允許，則每個任務的 page_frag，否則每個套接字的 page_frag。

void _sock_tx_timestamp(struct sock *sk, const struct sockcm_cookie *sockc, __u8 *tx_flags, __u32 *tskey)¶: 檢查是否要對傳出資料包進行時間戳

引數

struct sock *sk: 傳送此資料包的套接字
const struct sockcm_cookie *sockc: 指向套接字 cmsg cookie 的指標以獲取時間戳資訊
__u8 *tx_flags: 已完成時間戳說明
__u32 *tskey: 填充了下一個 sk_tskey（不適用於使用 seqno 的 TCP）

注意

呼叫者應注意初始 *tx_flags 值（通常為 0）

void sk_eat_skb(struct sock *sk, struct sk_buff *skb)¶: 如果不再需要，則釋放 skb

引數

struct sock *sk: 從中提取此 skb 的套接字
設定 skb dst: 要提取的套接字緩衝區

描述

必須在停用中斷或鎖定套接字的情況下呼叫此例程，以便套接字緩衝區佇列操作可以正常進行。

struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)¶: 將 socket 繫結到 file

引數

struct socket *sock

const struct sock *sk

int flags

檔案狀態標誌

const char *dname

協議名稱

返回與 sock 繫結的 file，並將其隱式儲存在 sock->file 中。如果 dname 為 NULL，則設定為“”。

如果失敗，則釋放 sock，並返回 ERR 指標。

此函式在內部使用 GFP_KERNEL。

struct socket *sock_from_file(struct file *file)¶: 返回繫結到 file 的 socket。

引數

struct file *file

檔案

如果失敗，則返回 NULL。

struct socket *sockfd_lookup(int fd, int *err)¶: 從檔案號轉到其套接字槽

引數

int fd

檔案控制代碼

int *err

指向錯誤程式碼返回的指標

傳入的檔案控制代碼已鎖定，並返回與其繫結的套接字。如果發生錯誤，則 err 指標將被負 errno 程式碼覆蓋，並返回 NULL。該函式檢查無效控制代碼和傳遞非套接字的控制代碼。

如果成功，則返回套接字物件指標。

struct socket *sock_alloc(void)¶: 分配一個套接字

引數

void: 無引數

描述

分配一個新的 inode 和 socket 物件。這兩個物件繫結在一起並進行初始化。然後返回 socket。如果 inode 不夠用，則返回 NULL。此函式在內部使用 GFP_KERNEL。

void sock_release(struct socket *sock)¶: 關閉一個 socket

引數

struct socket *sock

要關閉的 socket

如果 socket 有釋放回調函式，則從協議棧中釋放該 socket，然後如果 socket 繫結到 inode 而不是檔案，則釋放該 inode。

int sock_sendmsg(struct socket *sock, struct msghdr *msg)¶: 透過 sock 傳送訊息

引數

struct socket *sock

const struct sock *sk

struct msghdr *msg

要傳送的訊息

透過 sock 傳送 msg，透過 LSM。返回已傳送的位元組數，或錯誤程式碼。

int kernel_sendmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec, size_t num, size_t size)¶: 透過 sock 傳送訊息（核心空間）

引數

struct socket *sock

const struct sock *sk

struct msghdr *msg

訊息頭

struct kvec *vec

核心 vec

size_t num

vec 陣列長度

size_t size

總訊息資料大小

使用 vec 構建訊息資料，並透過 sock 傳送。返回已傳送的位元組數，或錯誤程式碼。

int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)¶: 從 sock 接收訊息

引數

struct socket *sock

const struct sock *sk

struct msghdr *msg

要接收的訊息

int flags

訊息標誌

從 sock 接收 msg，透過 LSM。返回接收到的總位元組數，或錯誤。

int kernel_recvmsg(struct socket *sock, struct msghdr *msg, struct kvec *vec, size_t num, size_t size, int flags)¶: 從 socket 接收訊息（核心空間）

引數

struct socket *sock

從中接收訊息的 socket

struct msghdr *msg

接收到的訊息

struct kvec *vec

用於訊息資料的輸入 s/g 陣列

size_t num

輸入 s/g 陣列的大小

size_t size

要讀取的位元組數

int flags

訊息標誌（MSG_DONTWAIT 等）

在返回時，msg 結構包含 vec 引數中傳入的 scatter/gather 陣列。修改陣列，使其由原始陣列的未填充部分組成。

返回值是接收到的總位元組數，或錯誤。

int sock_create_lite(int family, int type, int protocol, struct socket **res)¶: 建立一個 socket

引數

int family

協議族（AF_INET，...）

int type

通訊型別（SOCK_STREAM，...）

int protocol

協議（0，...）

struct socket **res

新的 socket

建立一個新的 socket 並將其分配給 res，透過 LSM。新的 socket 初始化尚未完成，請參閱 kernel_accept()。返回 0 或錯誤。如果失敗，則將 res 設定為 NULL。此函式在內部使用 GFP_KERNEL。

int __sock_create(struct net *net, int family, int type, int protocol, struct socket **res, int kern)¶: 建立一個 socket

引數

struct net *net

net 名稱空間

int family

協議族（AF_INET，...）

int type

通訊型別（SOCK_STREAM，...）

int protocol

協議（0，...）

struct socket **res

新的 socket

int kern

用於核心空間 socket 的布林值

建立一個新的 socket 並將其分配給 res，透過 LSM。返回 0 或錯誤。如果失敗，則將 res 設定為 NULL。如果 socket 位於核心空間中，則 kern 必須設定為 true。此函式在內部使用 GFP_KERNEL。

int sock_create(int family, int type, int protocol, struct socket **res)¶: 建立一個 socket

引數

int family

協議族（AF_INET，...）

int type

通訊型別（SOCK_STREAM，...）

int protocol

協議（0，...）

struct socket **res

新的 socket

圍繞 __sock_create() 的一個包裝器。返回 0 或錯誤。此函式在內部使用 GFP_KERNEL。

int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)¶: 建立一個 socket（核心空間）

引數

struct net *net

net 名稱空間

int family

協議族（AF_INET，...）

int type

通訊型別（SOCK_STREAM，...）

int protocol

協議（0，...）

struct socket **res

新的 socket

圍繞 __sock_create() 的一個包裝器。返回 0 或錯誤。此函式在內部使用 GFP_KERNEL。

int sock_register(const struct net_proto_family *ops)¶: 新增一個 socket 協議處理程式

引數

const struct net_proto_family *ops

協議的描述

協議處理程式呼叫此函式來宣告其地址族，並將其連結到 socket 介面中。值 ops->family 對應於 socket 系統呼叫協議族。

void sock_unregister(int family)¶: 移除一個協議處理程式

引數

int family

要移除的協議族

協議處理程式呼叫此函式來移除其地址族，並將其從新的 socket 建立中取消連結。

如果協議處理程式是一個模組，那麼它可以利用模組引用計數來防止新的引用。如果協議處理程式不是一個模組，那麼它需要在 ops->create 例程中提供自己的保護。

int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)¶: 將地址繫結到 socket（核心空間）

引數

struct socket *sock

const struct sock *sk

struct sockaddr *addr

地址

int addrlen

地址的長度

返回 0 或錯誤。

int kernel_listen(struct socket *sock, int backlog)¶: 將 socket 移動到偵聽狀態（核心空間）

引數

struct socket *sock

const struct sock *sk

int backlog

掛起的連線佇列大小

返回 0 或錯誤。

int kernel_accept(struct socket *sock, struct socket **newsock, int flags)¶: 接受連線（核心空間）

引數

struct socket *sock

偵聽 socket

struct socket **newsock

新的已連線 socket

int flags

標誌

flags 必須是 SOCK_CLOEXEC、SOCK_NONBLOCK 或 0。如果失敗，保證 newsock 為 NULL。返回 0 或錯誤。

int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, int flags)¶: 連線一個 socket（核心空間）

引數

struct socket *sock

const struct sock *sk

struct sockaddr *addr

地址

int addrlen

地址長度

int flags

標誌（O_NONBLOCK，...）

對於資料報 socket，addr 是預設情況下資料報傳送到的地址，也是接收資料報的唯一地址。對於流式 socket，嘗試連線到 addr。返回 0 或錯誤程式碼。

int kernel_getsockname(struct socket *sock, struct sockaddr *addr)¶: 獲取 socket 繫結的地址（核心空間）

引數

struct socket *sock

const struct sock *sk

struct sockaddr *addr

地址持有者

用 socket 繫結的地址填充 addr 指標。返回地址的位元組長度或錯誤程式碼。

int kernel_getpeername(struct socket *sock, struct sockaddr *addr)¶: 獲取 socket 連線的地址（核心空間）

引數

struct socket *sock

const struct sock *sk

struct sockaddr *addr

地址持有者

用 socket 連線的地址填充 addr 指標。返回地址的位元組長度或錯誤程式碼。

int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd: 關閉全雙工連線的一部分（核心空間）

引數

struct socket *sock

const struct sock *sk

enum sock_shutdown_cmd how

連線部分

返回 0 或錯誤。

u32 kernel_sock_ip_overhead(struct sock *sk)¶: 返回 socket 施加的 IP 開銷

引數

struct sock *sk

const struct sock *sk

此例程返回 socket 施加的 IP 開銷，即底層 IP 頭的長度，具體取決於這是一個 IPv4 還是 IPv6 socket，以及從 socket 上啟用的 IP 選項的長度。假設呼叫方擁有 socket 上的鎖。

void drop_reasons_register_subsys(enum skb_drop_reason_subsys subsys, const struct drop_reason_list *list)¶: 註冊另一個丟棄原因子系統

引數

enum skb_drop_reason_subsys subsys: 要註冊的子系統，不能是核心
const struct drop_reason_list *list: 子系統中的丟棄原因列表，必須指向靜態初始化的列表

void drop_reasons_unregister_subsys(enum skb_drop_reason_subsys subsys)¶: 登出一個丟棄原因子系統

引數

enum skb_drop_reason_subsys subsys: 要移除的子系統，不能是核心

注意

這將 synchronize_rcu() 以確保在返回時沒有使用者。

u32 napi_skb_cache_get_bulk(void **skbs, u32 n)¶: 從快取中獲取多個零填充的 skb 頭部

引數

void **skbs: 指向至少 n 大小的陣列的指標，用於填充 skb 指標
u32 n: 要提供的條目數

描述

嘗試從 NAPI percpu 快取中獲取 n 個 sk_buff 條目，並將指標寫入提供的陣列 skbs 中。如果可用條目較少，則嘗試補充快取，並在需要時從 MM 層批次分配差異。頭部將使用 memset() 或 __GFP_ZERO 進行零填充，因此它們已準備好用於 {,__}build_skb_around()，並且沒有附加任何資料緩衝區。必須僅從 BH 上下文中呼叫。

返回 skb dst_entry

成功分配的 skb 的數量（如果沒有實際分配，則為 n: 所需，或 kmem_cache_alloc_bulk() 沒有失敗）。

struct sk_buff *build_skb_around(struct sk_buff *skb, void *data, unsigned int frag_size)¶: 圍繞提供的 skb 構建網路緩衝區

引數

設定 skb dst: 呼叫方提供的 sk_buff，必須 memset 清除
void *data: 呼叫方提供的資料緩衝區
unsigned int frag_size: 資料大小

struct sk_buff *napi_build_skb(void *data, unsigned int frag_size)¶: 構建網路緩衝區

引數

void *data: 呼叫方提供的資料緩衝區
unsigned int frag_size: 資料大小

描述

__napi_build_skb() 的版本，當資料是頁面或頁面片段時，負責 skb->head_frag 和 skb->pfmemalloc。

成功時返回一個新的 sk_buff，分配失敗時返回 NULL。

struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask, int flags, int node)¶: struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)¶

引數

unsigned int size

分配網路緩衝區

gfp_t gfp_mask

gfp_t priority

int flags

如果設定了 SKB_ALLOC_FCLONE，則從 fclone 快取而不是頭部快取分配，並分配一個克隆的（子）skb。如果設定了 SKB_ALLOC_RX，則在需要將資料寫回時，將對分配使用 __GFP_MEMALLOC

int node

在其上分配記憶體的 numa 節點

分配一個新的 sk_buff。返回的緩衝區沒有頭部空間，尾部空間至少為 size 位元組。該物件具有引用計數 1。返回值是緩衝區。如果失敗，則返回值為 NULL。

緩衝區只能使用 GFP_ATOMIC 的 gfp_mask 從中斷中分配。

struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int len, gfp_t gfp_mask)¶: 在特定裝置上為 rx 分配一個 skbuff

引數

struct net_device *dev

要接收的網路裝置

unsigned int len

要分配的長度

gfp_t gfp_mask

get_free_pages 掩碼，傳遞給 alloc_skb

分配一個新的 sk_buff 併為其分配一個使用計數。緩衝區具有內建的 NET_SKB_PAD 預留空間。使用者應該分配他們認為需要的預留空間，而無需考慮內建空間。內建空間用於最佳化。

如果沒有空閒記憶體，則返回 NULL。

struct sk_buff *napi_alloc_skb(struct napi_struct *napi, unsigned int len)¶: 為特定 NAPI 例項中的 rx 分配 skbuff

引數

struct napi_struct *napi

為此緩衝區分配的 NAPI 例項

unsigned int len

要分配的長度

分配一個新的 sk_buff 以用於 NAPI 接收。此緩衝區將嘗試從僅用於 NAPI Rx 分配的特殊保留區域分配頭部。透過這樣做，我們可以透過避免停用和重新啟用 IRQ 來節省幾個 CPU 週期。

如果沒有空閒記憶體，則返回 NULL。

void __kfree_skb(struct sk_buff *skb)¶: 私有函式

引數

設定 skb dst

const struct sk_buff *skb

釋放 sk_buff。釋放任何附加到緩衝區的內容。清理狀態。這是一個內部輔助函式。使用者應始終呼叫 kfree_skb

void __fix_address sk_skb_reason_drop(struct sock *sk, struct sk_buff *skb, enum skb_drop_reason reason)¶: 釋放具有特殊原因的 sk_buff

引數

struct sock *sk

接收 skb 的套接字，如果不可用，則為 NULL

設定 skb dst

釋放具有“NOT_SPECIFIED”原因的 sk_buff

enum skb_drop_reason reason

丟棄此 skb 的原因

減少緩衝區的引用計數，如果使用計數達到零則釋放它。同時，將接收套接字和丟棄原因傳遞給 'kfree_skb' 跟蹤點。

void skb_tx_error(struct sk_buff *skb)¶: 報告 sk_buff xmit 錯誤

引數

設定 skb dst

觸發錯誤的緩衝區

如果裝置回撥跟蹤此 skb，則報告 xmit 錯誤。skb 之後必須釋放。

void consume_skb(struct sk_buff *skb)¶: 釋放 skbuff

引數

設定 skb dst

釋放具有“NOT_SPECIFIED”原因的 sk_buff

減少緩衝區的引用計數，如果使用計數達到零則釋放它。與 kfree_skb 的功能相同，但 kfree_skb 假設幀在失敗後被丟棄，並記錄這一點

struct sk_buff *alloc_skb_for_msg(struct sk_buff *first)¶: 分配 sk_buff 以包裝 frag 列表，形成一條訊息

引數

struct sk_buff *first: 訊息的第一個 sk_buff

struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)¶: 將一個 skb 變形為另一個

引數

struct sk_buff *dst

接收內容的 skb

struct sk_buff *src

提供內容的 skb

這與 skb_clone 相同，只是目標 skb 由使用者提供。

目標 skb 在退出時返回。

int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask)¶: 將使用者空間 skb frag 緩衝區複製到核心

引數

設定 skb dst

要修改的 skb

gfp_t gfp_mask

分配優先順序

必須在帶有 SKBFL_ZEROCOPY_ENABLE 的 skb 上呼叫此函式。它會將所有 frags 複製到核心並刪除對使用者空間頁面的引用。

如果此函式是從中斷呼叫的，則 gfp_mask() 必須是 GFP_ATOMIC。

成功時返回 0，如果無法分配核心記憶體以複製到則返回負錯誤程式碼。

struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)¶: 複製 sk_buff

引數

設定 skb dst

要克隆的緩衝區

gfp_t gfp_mask

分配優先順序

複製一個 sk_buff。新的不屬於套接字。兩個副本共享相同的資料包資料，但不共享結構。新緩衝區的引用計數為 1。如果分配失敗，函式返回 NULL，否則返回新緩衝區。

如果此函式是從中斷呼叫的，則 gfp_mask() 必須是 GFP_ATOMIC。

struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t gfp_mask)¶: 建立 sk_buff 的私有副本

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要複製的緩衝區

gfp_t gfp_mask

分配優先順序

建立 sk_buff 及其資料的副本。當呼叫者希望修改資料並需要資料的私有副本進行更改時，會使用此方法。失敗時返回 NULL，成功時返回緩衝區的指標。返回的緩衝區的引用計數為 1。

作為副產品，此函式會將非線性 sk_buff 轉換為線性 sk_buff，以便 sk_buff 完全變為私有，並且允許呼叫者修改返回的緩衝區的所有資料。這意味著當只打算修改標頭時，不建議使用此函式。請改用 pskb_copy()。

struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom, gfp_t gfp_mask, bool fclone)¶: 建立帶有私有頭的 sk_buff 副本。

引數

設定 skb dst

要複製的緩衝區

int headroom

新 skb 的預留空間

gfp_t gfp_mask

分配優先順序

bool fclone

如果為 true，則從 fclone 快取而不是頭部快取分配 skb 的副本；建議對於可能克隆副本的情況，將其設定為 true

建立 sk_buff 及其部分資料的副本，該部分資料位於標頭中。分段資料保持共享。當呼叫者希望僅修改 sk_buff 的標頭並需要標頭的私有副本進行更改時，會使用此方法。失敗時返回 NULL，成功時返回緩衝區的指標。返回的緩衝區的引用計數為 1。

int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask)¶: 重新分配 sk_buff 的標頭

引數

設定 skb dst

要重新分配的緩衝區

int nhead

要在頭部新增的空間

int ntail

要在尾部新增的空間

gfp_t gfp_mask

分配優先順序

展開（或者如果 nhead 和 ntail 為零，則建立相同副本）skb 的標頭。 sk_buff 本身不會更改。 sk_buff 必須具有引用計數 1。如果成功，則返回零；如果展開失敗，則返回錯誤。在最後一種情況下，sk_buff 不會更改。

指向 skb 標頭的所有指標都可能更改，並且必須在呼叫此函式後重新載入。

struct sk_buff *skb_expand_head(struct sk_buff *skb, unsigned int headroom)¶: 重新分配 sk_buff 的標頭

引數

設定 skb dst

要重新分配的緩衝區

unsigned int headroom

所需的頭部空間

與 skb_realloc_headroom 不同，此方法在可能的情況下不會分配新的 skb；根據需要將 skb->sk 複製到新的 skb，如果失敗，則釋放原始 skb。

它期望增加預留空間，否則會生成警告。

struct sk_buff *skb_copy_expand(const struct sk_buff *skb, int newheadroom, int newtailroom, gfp_t gfp_mask)¶: 複製和展開 sk_buff

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

要複製的緩衝區

int newheadroom

頭部的新空閒位元組

int newtailroom

尾部的新空閒位元組

gfp_t gfp_mask

分配優先順序

建立 sk_buff 及其資料的副本，並在執行此操作時分配額外的空間。

當呼叫者希望修改資料並需要資料的私有副本進行更改以及更多用於新欄位的空間時，會使用此方法。失敗時返回 NULL，成功時返回緩衝區的指標。返回的緩衝區的引用計數為 1。

如果此函式是從中斷呼叫的，則必須傳遞 GFP_ATOMIC 作為分配優先順序。

int __skb_pad(struct sk_buff *skb, int pad, bool free_on_error)¶: int skb_pad(struct sk_buff *skb, int pad)¶

引數

設定 skb dst

將 skb 的尾部填充為零

要填充的緩衝區

int pad

bool free_on_error

錯誤時釋放緩衝區

要填充的空間

在記憶體不足的情況下可能會返回錯誤。如果 free_on_error 為 true，則 skb 在錯誤時釋放。

void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)¶: 將資料新增到可能分段的緩衝區的尾部

引數

設定 skb dst

要使用的緩衝區的開頭

struct sk_buff *tail

要使用的緩衝區的尾部片段

int len

要新增的資料量

此函式擴充套件了可能分段的緩衝區的使用資料區域。tail 必須是 skb 的最後一個片段 - 或 skb 本身。如果這會超過總緩衝區大小，核心將會崩潰。返回指向額外資料的第一個位元組的指標。

void *skb_put(struct sk_buff *skb, unsigned int len)¶: 將資料新增到緩衝區

引數

設定 skb dst

要使用的緩衝區

unsigned int len

要新增的資料量

此函式擴充套件了緩衝區的使用資料區域。如果這會超過總緩衝區大小，核心將會崩潰。返回指向額外資料的第一個位元組的指標。

void *skb_push(struct sk_buff *skb, unsigned int len)¶: 將資料新增到緩衝區的開頭

引數

設定 skb dst

要使用的緩衝區

unsigned int len

要新增的資料量

此函式在緩衝區開頭擴充套件了緩衝區的使用資料區域。如果這會超過總緩衝區預留空間，核心將會崩潰。返回指向額外資料的第一個位元組的指標。

void *skb_pull(struct sk_buff *skb, unsigned int len)¶: 從緩衝區的開頭刪除資料

引數

設定 skb dst

要使用的緩衝區

unsigned int len

要刪除的資料量

此函式從緩衝區的開頭刪除資料，將記憶體返回到預留空間。返回指向緩衝區中下一個資料的指標。拉取資料後，未來的推送將會覆蓋舊資料。

void *skb_pull_data(struct sk_buff *skb, size_t len)¶: 從緩衝區的開頭刪除資料，返回其原始位置。

引數

設定 skb dst

要使用的緩衝區

size_t len

要刪除的資料量

此函式從緩衝區的開頭刪除資料，將記憶體返回到預留空間。返回指向緩衝區中原始資料的指標，並檢查是否有足夠的資料可供拉取。拉取資料後，未來的推送將會覆蓋舊資料。

void skb_trim(struct sk_buff *skb, unsigned int len)¶: 從緩衝區刪除結尾

引數

設定 skb dst

要更改的緩衝區

unsigned int len

新長度

透過從尾部刪除資料來縮短緩衝區的長度。如果緩衝區已低於指定的長度，則不會對其進行修改。skb 必須是線性的。

void *__pskb_pull_tail(struct sk_buff *skb, int delta)¶: 推進 skb 標頭的尾部

引數

設定 skb dst

要重新分配的緩衝區

int delta

要推進尾部的位元組數

該函式僅對分段的 sk_buff 有意義，它會展開標頭，向前移動其尾部，並從分段部分複製必要的資料。

sk_buff 必須具有引用計數 1。

如果拉取失敗，則返回 NULL（並且 sk_buff 不會更改），如果成功，則返回 skb 的新尾部的值。

指向 skb 標頭的所有指標都可能更改，並且必須在呼叫此函式後重新載入。

int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len)¶: 將位從 skb 複製到核心緩衝區

引數

測試 skb 是否從 PFMEMALLOC 保留區分配

源 skb

int offset

源中的偏移量

void *to

目標緩衝區

int len

要複製的位元組數

將指定數量的位元組從源 skb 複製到目標緩衝區。

注意！: 如果其原型發生更改，請檢查 arch/{*}/net/{*}.S 檔案，因為它從 BPF 彙編程式碼中呼叫。

int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len)¶: 將位從核心緩衝區儲存到 skb

引數

設定 skb dst

目標緩衝區

int offset

目標中的偏移量

const void *from

源緩衝區

int len

要複製的位元組數

將指定數量的位元組從源緩衝區複製到目標 skb。此函式處理遍歷片段列表等所有繁瑣的位。

int skb_zerocopy(struct sk_buff *to, struct sk_buff *from, int len, int hlen)¶: 將 skb 零複製到 skb

引數

struct sk_buff *to

目標緩衝區

struct sk_buff *from

源緩衝區

int len

要從源緩衝區複製的位元組數

int hlen

目標緩衝區中線性預留空間的大小

透過建立對源緩衝區中 frags 的引用，將最多 len 個位元組從 from 複製到 to。

由 skb_zerocopy_headlen() 計算的 hlen 指定 to 緩衝區中的預留空間。

返回值：0：一切正常 -ENOMEM：由於記憶體不足，無法孤立 from 的 frags -EFAULT：skb_copy_bits() 發現 skb 幾何圖形有問題

struct sk_buff *skb_dequeue(struct sk_buff_head *list)¶: 從佇列的頭部移除

引數

struct sk_buff_head *list

要從中出隊的列表

刪除列表的頭部。列表鎖被佔用，因此該函式可以與其他鎖定列表函式安全地一起使用。返回頭部項，如果列表為空，則返回 NULL。

struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list)¶: 從佇列的尾部移除

引數

struct sk_buff_head *list

要從中出隊的列表

刪除列表的尾部。列表鎖被佔用，因此該函式可以與其他鎖定列表函式安全地一起使用。返回尾部項，如果列表為空，則返回 NULL。

void skb_queue_purge_reason(struct sk_buff_head *list, enum skb_drop_reason reason)¶: 清空列表

引數

struct sk_buff_head *list

要清空的列表

enum skb_drop_reason reason

丟棄原因

刪除 sk_buff 列表中的所有緩衝區。從列表中刪除每個緩衝區並減少一個引用。此函式佔用列表鎖，並且對於其他列表鎖定函式是原子的。

void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk)¶: 在列表頭部排隊緩衝區

引數

struct sk_buff_head *list

要使用的列表

struct sk_buff *newsk

要排隊的緩衝區

將緩衝區排隊到列表的開頭。此函式獲取列表鎖，並且可以與其他鎖定 sk_buff 函式安全地一起使用。

一個緩衝區不能同時放置在兩個列表上。

void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)¶: 在列表尾部排隊緩衝區

引數

struct sk_buff_head *list

要使用的列表

struct sk_buff *newsk

要排隊的緩衝區

將緩衝區排隊到列表的末尾。此函式獲取列表鎖，並且可以與其他鎖定 sk_buff 函式安全地一起使用。

一個緩衝區不能同時放置在兩個列表上。

void skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)¶: 從列表中刪除緩衝區

引數

設定 skb dst

要刪除的緩衝區

struct sk_buff_head *list

要使用的列表

從列表中刪除資料包。獲取列表鎖，並且此函式相對於其他列表鎖定呼叫是原子的。

你必須知道 SKB 在哪個列表上。

void skb_append(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list)¶: 追加緩衝區

引數

struct sk_buff *old

要插入的緩衝區之後

struct sk_buff *newsk

要插入的緩衝區

struct sk_buff_head *list

要使用的列表

將資料包放置在列表中的給定資料包之後。獲取列表鎖，並且此函式相對於其他列表鎖定呼叫是原子的。一個緩衝區不能同時放置在兩個列表上。

void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len)¶: 在長度 len 處將分片的 skb 分成兩部分。

引數

設定 skb dst: 要拆分的緩衝區
struct sk_buff *skb1: 用於接收第二部分的緩衝區
const u32 len: skb 的新長度

void skb_prepare_seq_read(struct sk_buff *skb, unsigned int from, unsigned int to, struct skb_seq_state *st)¶: 準備 skb 資料的順序讀取

引數

設定 skb dst: 要讀取的緩衝區
unsigned int from: 要讀取的資料的較低偏移量
unsigned int to: 要讀取的資料的較高偏移量
struct skb_seq_state *st: 狀態變數

描述

初始化指定的狀態變數。必須在第一次呼叫 skb_seq_read() 之前呼叫。

unsigned int skb_seq_read(unsigned int consumed, const u8 **data, struct skb_seq_state *st)¶: 順序讀取 skb 資料

引數

unsigned int consumed: 呼叫者目前消耗的位元組數
const u8 **data: 要返回的資料的目標指標
struct skb_seq_state *st: 狀態變數

描述

相對於指定給 skb_prepare_seq_read() 的較低偏移量，在 consumed 處讀取一個 skb 資料塊。將資料塊的頭部分配給 data，並返回塊的長度；如果到達 skb 資料或較高偏移量的末尾，則返回 0。

不需要呼叫者消耗所有返回的資料，即 consumed 通常設定為已消耗的位元組數，並且對 skb_seq_read() 的下一次呼叫將返回塊的剩餘部分。

注意 1：返回的每個資料塊的大小可以是任意的，: 此限制是零複製順序讀取潛在非線性資料的代價。
注意 2：目前尚未實現片段中的片段列表: 目前，state->root_skb 可以用堆疊替換以達到此目的。

void skb_abort_seq_read(struct skb_seq_state *st)¶: 中止 skb 資料的順序讀取

引數

struct skb_seq_state *st: 狀態變數

描述

如果 skb_seq_read() 未被呼叫直到返回 0，則必須呼叫。

int skb_copy_seq_read(struct skb_seq_state *st, int offset, void *to, int len)¶: 從 skb_seq_state 複製到緩衝區

引數

struct skb_seq_state *st: 源 skb_seq_state
int offset: 源中的偏移量
void *to: 目標緩衝區
int len: 要複製的位元組數

描述

將來自源 st 中 offset 位元組的 len 位元組複製到目標緩衝區 to。對於此函式的每個後續呼叫，offset 應該增加（或保持不變）。如果偏移量需要比上次使用時減少，則應首先重置 st。

返回 skb dst_entry

成功時返回 0，如果複製提前結束則返回 -EINVAL

unsigned int skb_find_text(struct sk_buff *skb, unsigned int from, unsigned int to, struct ts_config *config)¶: 在 skb 資料中查詢文字模式

引數

設定 skb dst: 要在其中查詢的緩衝區
unsigned int from: 搜尋偏移量
unsigned int to: 搜尋限制
struct ts_config *config: 文字搜尋配置

描述

根據指定的文字搜尋配置在 skb 資料中查詢模式。使用 textsearch_next() 來檢索模式的後續出現。如果未找到匹配項，則返回第一次出現的偏移量或 UINT_MAX。

void *skb_pull_rcsum(struct sk_buff *skb, unsigned int len)¶: 拉取 skb 並更新接收校驗和

引數

設定 skb dst

要更新的緩衝區

unsigned int len

pull 的資料長度

此函式對資料包執行 skb_pull 並更新 CHECKSUM_COMPLETE 校驗和。除非您知道校驗和差異為零（例如，有效的 IP 標頭），否則應在接收路徑處理中使用它而不是 skb_pull，或者您要將 ip_summed 設定為 CHECKSUM_NONE。

struct sk_buff *skb_segment(struct sk_buff *head_skb, netdev_features_t features)¶: 對 skb 執行協議分段。

引數

struct sk_buff *head_skb

要分段的緩衝區

netdev_features_t features

輸出路徑的特徵（請參見 dev->features）

此函式對給定的 skb 執行分段。它返回指向分段新 skb 列表中的第一個 skb 的指標。如果出現錯誤，它將返回 ERR_PTR(err)。

int skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)¶: 從套接字緩衝區填充一個分散聚集列表

引數

設定 skb dst

包含要對映的緩衝區的套接字緩衝區

struct scatterlist *sg

要對映到的分散聚集列表

int offset

開始對映的緩衝區內容的偏移量

int len

要對映的緩衝區空間長度

使用對映/指標填充指定的分散聚集列表，以對映到附加到套接字緩衝區的緩衝區空間的區域中。返回使用的分散列表項的數量，或者如果內容無法容納則返回 -EMSGSIZE。

int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)¶: 檢查套接字緩衝區的資料緩衝區是否可寫

引數

設定 skb dst

要檢查的套接字緩衝區。

int tailbits

要新增的尾部空間量

struct sk_buff **trailer

指向 tailbits 空間開始的 skb 的返回指標

確保附加到套接字緩衝區的資料緩衝區是可寫的。如果它們不可寫，則建立資料緩衝區的私有副本，並將套接字緩衝區設定為改用這些副本。

如果給定了 tailbits，則確保有空間在套接字緩衝區的當前末尾之外寫入 tailbits 位元組的資料。 trailer 將設定為指向此空間開始的 skb。

將返回完全對映 COW'd 和擴充套件套接字緩衝區所需的分散列表元素的數量。

struct sk_buff *skb_clone_sk(struct sk_buff *skb)¶: 建立 skb 的克隆，並獲取對套接字的引用

引數

設定 skb dst: 要克隆的 skb

描述

此函式建立緩衝區的克隆，該緩衝區保持對 sk_refcnt 的引用。透過此函式建立的緩衝區旨在透過 sock_queue_err_skb 返回，或透過 kfree_skb 釋放。

當將使用此函式分配的緩衝區傳遞給 sock_queue_err_skb 時，有必要將該呼叫包裝在 sock_hold/sock_put 中，以防止在套接字排隊到 sk_error_queue 之前被釋放。

bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off)¶: 設定和驗證資料包的部分 csum 值

引數

設定 skb dst: 要設定的 skb
u16 start: skb->data 之後開始校驗和的位元組數。
u16 off: 從開始到放置校驗和的偏移量。

描述

對於不受信任的部分校驗和資料包，我們需要確保 skb->csum_start 和 skb->csum_offset 的值有效，這樣我們才不會發生 oops。

此函式檢查並設定這些值和 skb->ip_summed：如果此函式返回 false，則應丟棄該資料包。

int skb_checksum_setup(struct sk_buff *skb, bool recalculate)¶: 設定部分校驗和偏移量

引數

設定 skb dst: 要設定的 skb
bool recalculate: 如果為 true，則將重新計算偽標頭校驗和

struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb, unsigned int transport_len, __sum16 (*skb_chkf)(struct sk_buff *skb))¶: 驗證 skb 的校驗和

引數

設定 skb dst: 要檢查的 skb
unsigned int transport_len: 網路標頭之外的資料長度
__sum16(*skb_chkf)(struct sk_buff *skb): 要使用的校驗和函式

描述

將給定的校驗和函式 skb_chkf 應用於提供的 skb。返回已檢查且可能經過修剪的 skb。如果出現錯誤，則返回 NULL。

如果 skb 在給定的傳輸長度之外有資料，則檢查並返回經過修剪和克隆的 skb。

如果 skb 與提供的 skb 不同，則呼叫者需要設定 skb 傳輸標頭並釋放任何返回的 skb。

bool skb_try_coalesce(struct sk_buff *to, struct sk_buff *from, bool *fragstolen, int *delta_truesize)¶: 嘗試將 skb 合併到先前的 skb

引數

struct sk_buff *to: 先前的緩衝區
struct sk_buff *from: 要新增的緩衝區
bool *fragstolen: 指向布林值的指標
int *delta_truesize: 分配的記憶體比請求的多多少

void skb_scrub_packet(struct sk_buff *skb, bool xnet)¶: 擦除 skb

引數

設定 skb dst: 要清理的緩衝區
bool xnet: 資料包正在跨越 netns

描述

skb_scrub_packet 可用於在將資料包封裝或解封裝到隧道中/從隧道中解封裝之後。在這些操作期間必須清除一些資訊。 skb_scrub_packet 也可用於在將 skb 注入到另一個名稱空間之前清理 skb (xnet == true)。我們必須清除 skb 中可能影響名稱空間隔離的所有資訊。

int skb_eth_pop(struct sk_buff *skb)¶: 刪除資料包頭部的乙太網標頭

引數

設定 skb dst: 要修改的套接字緩衝區

描述

刪除 skb 的乙太網標頭。

期望 skb->data 指向 mac 標頭並且不存在 VLAN 標記。

成功時返回 0，否則返回 -errno。

int skb_eth_push(struct sk_buff *skb, const unsigned char *dst, const unsigned char *src)¶: 在資料包頭部新增新的乙太網標頭

引數

設定 skb dst: 要修改的套接字緩衝區
const unsigned char *dst: 新標頭的目標 MAC 地址
const unsigned char *src: 新標頭的源 MAC 地址

描述

在 skb 前面新增一個新的乙太網標頭。

期望 skb->data 指向必須為空的 mac 標頭。

成功時返回 0，否則返回 -errno。

int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto, int mac_len, bool ethernet)¶: 從資料包的開頭起，在 mac_len 位元組之後推送新的 MPLS 標頭

引數

設定 skb dst: const struct sk_buff *skb
__be32 mpls_lse: 要推送的 MPLS 標籤堆疊條目
__be16 mpls_proto: 新 MPLS 標頭的 ethertype（期望 0x8847 或 0x8848）
int mac_len: MAC 標頭的長度
bool ethernet: 標誌，指示在 skb_mpls_push 之後生成的資料包是否為乙太網資料包

描述

期望 skb->data 位於 mac 標頭處。

成功時返回 0，否則返回 -errno。

int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len, bool ethernet)¶: 彈出最外層的 MPLS 標頭

引數

設定 skb dst: const struct sk_buff *skb
__be16 next_proto: 彈出 MPLS 標頭後的標頭的 ethertype
int mac_len: MAC 標頭的長度
bool ethernet: 標誌，指示資料包是否為乙太網資料包

描述

期望 skb->data 位於 mac 標頭處。

成功時返回 0，否則返回 -errno。

int skb_mpls_update_lse(struct sk_buff *skb, __be32 mpls_lse)¶: 修改最外層的 MPLS 標頭並更新 csum

引數

設定 skb dst: const struct sk_buff *skb
__be32 mpls_lse: 要更新到的新 MPLS 標籤堆疊條目

描述

期望 skb->data 位於 mac 標頭處。

成功時返回 0，否則返回 -errno。

int skb_mpls_dec_ttl(struct sk_buff *skb)¶: 遞減最外層的 MPLS 標頭的 TTL

引數

設定 skb dst: const struct sk_buff *skb

描述

期望 skb->data 位於 mac 標頭處。

成功時返回 0，否則返回 -errno。

struct sk_buff *alloc_skb_with_frags(unsigned long header_len, unsigned long data_len, int order, int *errcode, gfp_t gfp_mask)¶: 分配帶有頁面片段的 skb

引數

unsigned long header_len: 線性部分的大小
unsigned long data_len: 片段中需要的長度
int order: 所需的最大頁面順序。
int *errcode: 指向錯誤程式碼的指標（如果有）
gfp_t gfp_mask: gfp_t priority

描述

這可用於分配分頁的 skb，給定片段的最大順序。

void skb_condense(struct sk_buff *skb)¶: 嘗試儘可能地消除碎片/frag_list。

引數

設定 skb dst: const struct sk_buff *skb

描述

可以用於在將 skb 新增到繁忙佇列之前節省記憶體。如果資料包在 frags 中有位元組，並且 skb->head 中有足夠的尾部空間，則拉取所有位元組，以便我們可以立即釋放 frags 並調整 truesize。

注意

我們不重新分配 skb->head，因此不會失敗。如果需要，呼叫者必須重新評估 skb->truesize。

void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id)¶: 為給定的擴充套件分配空間，如果需要則進行寫時複製（COW）。

引數

設定 skb dst: const struct sk_buff *skb
enum skb_ext_id id: 要為其分配空間的擴充套件。

描述

為給定的擴充套件分配足夠的空間。如果該擴充套件已經存在，則返回指向該擴充套件的指標。

如果 skb 被克隆，則應用寫時複製 (COW)，並且修改返回的記憶體不會更改克隆緩衝區的擴充套件空間。

返回指向擴充套件的指標；如果分配失敗，則返回 NULL。

ssize_t skb_splice_from_iter(struct sk_buff *skb, struct iov_iter *iter, ssize_t maxsize, gfp_t gfp)¶: 將頁面拼接（或複製）到 skbuff

引數

設定 skb dst: 要新增頁面的緩衝區
struct iov_iter *iter: 表示要新增的頁面的迭代器
ssize_t maxsize: 要新增的最大頁面數量
gfp_t gfp: 分配標誌

描述

這是一個常用的輔助函式，用於支援 MSG_SPLICE_PAGES。它從迭代器中提取頁面，並儘可能將其新增到套接字緩衝區，如果不可能（例如，如果它們是 slab 頁面），則將它們複製到片段。

返回拼接/複製的資料量；如果緩衝區中沒有足夠的空間來傳輸任何資料，則返回 -EMSGSIZE。

bool sk_ns_capable(const struct sock *sk, struct user_namespace *user_ns, int cap)¶: 通用套接字能力測試

引數

檢查 fclone 是否繁忙: 要在其上或透過其使用能力的套接字
struct user_namespace *user_ns: 要使用的能力的使用者名稱空間
int cap: 要使用的能力

描述

測試套接字的開啟者在建立套接字時是否具有以及當前程序是否在使用者名稱空間 user_ns 中具有能力 cap。

bool sk_capable(const struct sock *sk, int cap)¶: 套接字全域性能力測試

引數

檢查 fclone 是否繁忙: 要在其上或透過其使用能力的套接字
int cap: 要使用的全域性能力

描述

測試套接字的開啟者在建立套接字時是否具有以及當前程序是否在所有使用者名稱空間中都具有能力 cap。

bool sk_net_capable(const struct sock *sk, int cap)¶: 網路名稱空間套接字能力測試

引數

檢查 fclone 是否繁忙: 要在其上或透過其使用能力的套接字
int cap: 要使用的能力

描述

測試套接字的開啟者在建立套接字時是否具有以及當前程序是否對套接字所屬的網路名稱空間具有能力 cap。

void sk_set_memalloc(struct sock *sk)¶: 設定 SOCK_MEMALLOC

引數

struct sock *sk: 要在其上設定的套接字

描述

在套接字上設定 SOCK_MEMALLOC 以訪問緊急儲備。管理員有責任調整 min_free_kbytes 以滿足要求

struct sock *sk_alloc(struct net *net, int family, gfp_t priority, struct proto *prot, int kern)¶: 所有套接字物件都在此處分配

引數

struct net *net: 適用的網路名稱空間
int family: 協議族
要分配的大小: 用於分配（GFP_KERNEL, GFP_ATOMIC 等）
struct proto *prot: 與此新 sock 例項關聯的 struct proto
int kern: 這是否是一個核心套接字？

struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)¶: 克隆一個套接字，並鎖定其克隆

引數

檢查 fclone 是否繁忙

要克隆的套接字

const gfp_t priority

用於分配（GFP_KERNEL, GFP_ATOMIC 等）

呼叫者必須解鎖套接字，即使在錯誤路徑中（bh_unlock_sock(newsk)）

bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)¶: 檢查 page_frag 是否包含足夠的空間

引數

unsigned int sz: 我們想要獲得的片段的最小大小
struct page_frag *pfrag: 指向 page_frag 的指標
gfp_t gfp: 記憶體分配的優先順序

注意

雖然此分配器嘗試使用高階頁面，但不能保證分配成功。因此，sz 必須小於或等於 PAGE_SIZE。

int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)¶: 等待資料到達 sk_receive_queue

引數

struct sock *sk: 要等待的 sock
long *timeo: 等待多久
測試 skb 是否從 PFMEMALLOC 保留區分配: 在 sk_receive_queue 上看到的最後一個 skb

描述

現在套接字狀態（包括 sk->sk_err）僅在鎖定下更改，因此我們可以在加入等待佇列後省略檢查。我們僅在 schedule() 之前檢查接收佇列作為最佳化； release_sock() 很有可能添加了新資料。

int __sk_mem_schedule(struct sock *sk, int size, int kind)¶: 增加 sk_forward_alloc 和 memory_allocated

引數

struct sock *sk

const struct sock *sk

int size

要分配的記憶體大小

int kind

分配型別

如果 kind 是 SK_MEM_SEND，則表示 wmem 分配。否則，它表示 rmem 分配。此函式假設具有 memory_pressure 的協議使用 sk_wmem_queued 作為寫入緩衝區記帳。

void __sk_mem_reclaim(struct sock *sk, int amount)¶: 回收 sk_forward_alloc 和 memory_allocated

引數

struct sock *sk: const struct sock *sk
int amount: 位元組數（向下舍入到 PAGE_SIZE 的倍數）

struct sk_buff *__skb_try_recv_datagram(struct sock *sk, struct sk_buff_head *queue, unsigned int flags, int *off, int *err, struct sk_buff **last)¶: 接收一個數據報 skbuff

引數

struct sock *sk

const struct sock *sk

struct sk_buff_head *queue

從中接收資料的套接字佇列

unsigned int flags

MSG_ 標誌

int *off

窺視 skb 的位元組偏移量。返回 skb 中資料實際開始的偏移量

int *err

返回的錯誤程式碼

struct sk_buff **last

設定為最後窺視的訊息，以告知等待函式窺視時要查詢的內容

獲取一個數據報 skbuff，瞭解窺視、非阻塞喚醒和可能的競爭。這取代了 packet、raw 和 udp 中的相同程式碼，以及 IPX AX.25 和 Appletalk。它還最終修復了資料報套接字的長期窺視和讀取競爭。如果你更改此例程，請記住它必須是可重入的。

如果返回了 skb，此函式將鎖定套接字，因此呼叫者需要在該情況下解鎖套接字（通常透過呼叫 skb_free_datagram）。如果無法獲得資料，則返回 NULL，並且 err 設定為 -EAGAIN；如果檢測到錯誤，則設定為其他值。

從今天開始，它不鎖定套接字。此功能
沒有競爭條件。這項措施應該/可以改善
在高負載下顯著提高資料報套接字延遲，
當將資料複製到使用者空間花費大量時間時。
(順便說一句，我剛剛殺死了 IP/IPv6/core/netlink/packet 中最後一個 cli()
1. 偉大的勝利。)
--ANK (980729)

當我們發現沒有資料等待時，測試的順序是由 POSIX 1003.1g 非常明確地指定的，如果沒有標準，請不要更改它們。

int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags)¶: 強制釋放資料報 skbuff

引數

struct sock *sk

const struct sock *sk

設定 skb dst

資料報 skbuff

unsigned int flags

MSG_ 標誌

此函式釋放由 skb_recv_datagram 接收的資料報 skbuff。flags 引數必須與 skb_recv_datagram 使用的引數匹配。

如果設定了 MSG_PEEK 標誌，並且資料包仍在套接字的接收佇列中，則會在釋放資料包之前將其從佇列中取出。

此函式當前僅在獲取 sk_receive_queue 鎖時停用 BH。因此，不得在 IRQ 上下文中獲取該鎖的上下文中使用它。

如果資料包由我們移除，則返回 0。

int skb_copy_and_crc32c_datagram_iter(const struct sk_buff *skb, int offset, struct iov_iter *to, int len, u32 *crcp)¶: 將資料報復制到 iovec 迭代器並更新 CRC32C 值。

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要複製的緩衝區
int offset: 從緩衝區開始複製的偏移量
struct iov_iter *to: 要複製到的 iovec 迭代器
int len: 要從緩衝區複製到 iovec 的資料量
u32 *crcp: 指向要更新的 CRC32C 值的指標

返回 skb dst_entry

成功時返回 0，複製過程中發生故障時返回 -EFAULT。

int skb_copy_datagram_iter(const struct sk_buff *skb, int offset, struct iov_iter *to, int len)¶: 將資料報復制到 iovec 迭代器。

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要複製的緩衝區
int offset: 從緩衝區開始複製的偏移量
struct iov_iter *to: 要複製到的 iovec 迭代器
int len: 要從緩衝區複製到 iovec 的資料量

int skb_copy_datagram_from_iter(struct sk_buff *skb, int offset, struct iov_iter *from, int len)¶: 從 iov_iter 複製資料報。

引數

設定 skb dst

要複製的緩衝區

int offset

開始複製到的緩衝區中的偏移量

struct iov_iter *from

複製源

int len

要從 iovec 複製到緩衝區的資料量

返回 0 或 -EFAULT。

int zerocopy_sg_from_iter(struct sk_buff *skb, struct iov_iter *from)¶: 從 iov_iter 構建零複製資料報

引數

設定 skb dst

要複製的緩衝區

struct iov_iter *from

要從中複製的源

該函式將首先複製到 headlen，然後固定使用者空間頁面並透過它們構建 frags。

返回 0、-EFAULT 或 -EMSGSIZE。

int skb_copy_and_csum_datagram_msg(struct sk_buff *skb, int hlen, struct msghdr *msg)¶: 將 skb 複製並校驗和到使用者 iovec。

引數

設定 skb dst

skbuff

int hlen

硬體長度

struct msghdr *msg

目的地

呼叫者_必須_檢查 skb 是否適合此 iovec。

返回 skb dst_entry

0 - 成功。: -EINVAL - 校驗和失敗。 -EFAULT - 複製期間發生故障。

__poll_t datagram_poll(struct file *file, struct socket *sock, poll_table *wait)¶: 通用資料報輪詢

引數

struct file *file

檔案結構

struct socket *sock

const struct sock *sk

poll_table *wait

輪詢表

資料報輪詢：再次完全通用。這也處理了排序的資料包套接字，前提是套接字接收佇列只儲存準備接收的資料。

注意

當你不為此協議使用此例程時，: 並且你使用的寫入策略與 sock_writeable() 不同，那麼請提供你自己的 write_space 回撥。

int sk_stream_wait_connect(struct sock *sk, long *timeo_p)¶: 等待套接字進入連線狀態

引數

struct sock *sk: 要等待的 sock
long *timeo_p: 等待多久

描述

必須在鎖定套接字的情況下呼叫。

int sk_stream_wait_memory(struct sock *sk, long *timeo_p)¶: 等待套接字獲得更多記憶體

引數

struct sock *sk: 要等待記憶體的套接字
long *timeo_p: 等待多久

套接字過濾器¶

int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap)¶: 透過套接字過濾器執行資料包

引數

struct sock *sk: 與 sk_buff 關聯的 sock
設定 skb dst: 要過濾的緩衝區
unsigned int cap: eBPF 程式可以修剪資料包的最短長度的限制

描述

執行 eBPF 程式，然後將 skb->data 裁剪為程式返回的正確大小。如果 pkt_len 為 0，則丟棄資料包。如果 skb->len 小於 pkt_len，則保留整個 skb->data。這是 bpf_prog_run 的套接字級別包裝器。如果應接受資料包，則返回 0；如果應丟棄資料包，則返回 -EPERM。

int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog)¶: 建立一個未附加的過濾器

引數

struct bpf_prog **pfp: 建立的未附加的過濾器
struct sock_fprog_kern *fprog: 過濾器程式

描述

建立一個獨立於任何套接字的過濾器。我們首先對其進行一些健全性檢查，以確保它以後不會在我們身上爆炸。如果發生錯誤或者過濾器沒有足夠的記憶體，則返回負的 errno 程式碼。成功時，返回值為零。

int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog, bpf_aux_classic_check_t trans, bool save_orig)¶: 從使用者緩衝區建立一個未附加的過濾器

引數

struct bpf_prog **pfp: 建立的未附加的過濾器
struct sock_fprog *fprog: 過濾器程式
bpf_aux_classic_check_t trans: 經典後驗證器轉換處理程式
bool save_orig: 儲存經典 BPF 程式

描述

此函式實際上與 bpf_prog_create() 相同，只是它從使用者空間提供的緩衝區中構建其 insns 緩衝區。它還允許傳遞 bpf_aux_classic_check_t 處理程式。

int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)¶: 附加一個套接字過濾器

引數

struct sock_fprog *fprog: 過濾器程式
struct sock *sk: 要使用的套接字

描述

附加使用者的過濾器程式碼。我們首先對其進行一些健全性檢查，以確保它以後不會在我們這裡爆炸。如果發生錯誤或過濾器的記憶體不足，則返回一個負的 errno 程式碼。成功時返回零。

通用網路統計資訊¶

struct gnet_stats_basic¶: 位元組/資料包吞吐量統計

定義:

struct gnet_stats_basic {
    __u64 bytes;
    __u32 packets;
};

成員

位元組: 看到的位元組數
資料包: 看到的資料包數

struct gnet_stats_rate_est¶: 速率估算器

定義:

struct gnet_stats_rate_est {
    __u32 bps;
    __u32 pps;
};

成員

bps: 當前位元組速率
pps: 當前資料包速率

struct gnet_stats_rate_est64¶: 速率估算器

定義:

struct gnet_stats_rate_est64 {
    __u64 bps;
    __u64 pps;
};

成員

bps: 當前位元組速率
pps: 當前資料包速率

struct gnet_stats_queue¶: 排隊統計

定義:

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

成員

qlen: 佇列長度
backlog: 佇列的 backlog 大小
drops: 丟棄的資料包數
requeues: 重新排隊數
overlimits: 超過限制的入隊數

struct gnet_estimator¶: 速率估算器配置

定義:

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

成員

interval: 取樣週期
ewma_log: 測量視窗權重的對數

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)¶: 在相容模式下啟動轉儲過程

引數

設定 skb dst: 套接字緩衝區，用於放入統計資訊 TLV
int type: 頂層統計資訊 TLV 的 TLV 型別
int tc_stats_type: 用於向後相容 struct tc_stats TLV 的 TLV 型別
int xstats_type: 用於向後相容 xstats TLV 的 TLV 型別
spinlock_t *lock: 統計資訊鎖
struct gnet_dump *d: 轉儲控制代碼
int padattr: 填充屬性

描述

初始化轉儲控制代碼，獲取統計資訊鎖，並將一個空 TLV 標頭附加到套接字緩衝區，以用作所有其他統計資訊 TLV 的容器。

轉儲控制代碼被標記為處於向後相容模式，告訴所有 gnet_stats_copy_XXX() 函式填充 struct tc_stats 的本地副本。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1。

int gnet_stats_start_copy(struct sk_buff *skb, int type, spinlock_t *lock, struct gnet_dump *d, int padattr)¶: 在相容模式下啟動轉儲過程

引數

設定 skb dst: 套接字緩衝區，用於放入統計資訊 TLV
int type: 頂層統計資訊 TLV 的 TLV 型別
spinlock_t *lock: 統計資訊鎖
struct gnet_dump *d: 轉儲控制代碼
int padattr: 填充屬性

描述

初始化轉儲控制代碼，獲取統計資訊鎖，並將一個空 TLV 標頭附加到套接字緩衝區，以用作所有其他統計資訊 TLV 的容器。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1。

int gnet_stats_copy_basic(struct gnet_dump *d, struct gnet_stats_basic_sync __percpu *cpu, struct gnet_stats_basic_sync *b, bool running)¶: 將基本統計資訊複製到統計資訊 TLV 中

引數

struct gnet_dump *d: 轉儲控制代碼
struct gnet_stats_basic_sync __percpu *cpu: 複製每個 CPU 的統計資訊
struct gnet_stats_basic_sync *b: 基本統計資訊
bool running: 如果 b 表示正在執行的 qdisc，則為 true，因此 b 的內部值可能會在基本讀取期間發生變化。僅在 cpu 為 NULL 時使用

上下文

任務；不得從 IRQ 或 BH 上下文執行

描述

將基本統計資訊附加到由 gnet_stats_start_copy() 建立的頂層 TLV。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gnet_stats_copy_basic_hw(struct gnet_dump *d, struct gnet_stats_basic_sync __percpu *cpu, struct gnet_stats_basic_sync *b, bool running)¶: 將基本 hw 統計資訊複製到統計資訊 TLV 中

引數

struct gnet_dump *d: 轉儲控制代碼
struct gnet_stats_basic_sync __percpu *cpu: 複製每個 CPU 的統計資訊
struct gnet_stats_basic_sync *b: 基本統計資訊
bool running: 如果 b 表示正在執行的 qdisc，則為 true，因此 b 的內部值可能會在基本讀取期間發生變化。僅在 cpu 為 NULL 時使用

上下文

任務；不得從 IRQ 或 BH 上下文執行

描述

將基本統計資訊附加到由 gnet_stats_start_copy() 建立的頂層 TLV。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gnet_stats_copy_rate_est(struct gnet_dump *d, struct net_rate_estimator __rcu **rate_est)¶: 將速率估算器統計資訊複製到統計資訊 TLV 中

引數

struct gnet_dump *d: 轉儲控制代碼
struct net_rate_estimator __rcu **rate_est: 速率估算器

描述

將速率估算器統計資訊附加到由 gnet_stats_start_copy() 建立的頂層 TLV。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gnet_stats_copy_queue(struct gnet_dump *d, struct gnet_stats_queue __percpu *cpu_q, struct gnet_stats_queue *q, __u32 qlen)¶: 將佇列統計資訊複製到統計資訊 TLV 中

引數

struct gnet_dump *d: 轉儲控制代碼
struct gnet_stats_queue __percpu *cpu_q: 每個 CPU 的佇列統計資訊
struct gnet_stats_queue *q: 佇列統計資訊
__u32 qlen: 佇列長度統計資訊

描述

將佇列統計資訊附加到由 gnet_stats_start_copy() 建立的頂層 TLV。如果每個 CPU 的佇列統計資訊可用，則使用它們。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gnet_stats_copy_app(struct gnet_dump *d, void *st, int len)¶: 將應用程式特定的統計資訊複製到統計資訊 TLV 中

引數

struct gnet_dump *d: 轉儲控制代碼
void *st: 應用程式特定的統計資訊資料
int len: 資料長度

描述

將應用程式特定的統計資訊附加到由 gnet_stats_start_copy() 建立的頂層 TLV，如果轉儲控制代碼處於向後相容模式，則記住 XSTATS 的資料。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gnet_stats_finish_copy(struct gnet_dump *d)¶: 完成轉儲過程

引數

struct gnet_dump *d: 轉儲控制代碼

描述

更正頂層 TLV 的長度，以包括 gnet_stats_copy_XXX() 呼叫新增的所有 TLV。如果使用了 gnet_stats_start_copy_compat()，則新增向後相容 TLV，並釋放統計資訊鎖。

成功時返回 0，如果套接字緩衝區中的空間不足，則返回 -1 並釋放統計資訊鎖。

int gen_new_estimator(struct gnet_stats_basic_sync *bstats, struct gnet_stats_basic_sync __percpu *cpu_bstats, struct net_rate_estimator __rcu **rate_est, spinlock_t *lock, bool running, struct nlattr *opt)¶: 建立一個新的速率估算器

引數

struct gnet_stats_basic_sync *bstats: 基本統計資訊
struct gnet_stats_basic_sync __percpu *cpu_bstats: 每個 CPU 的 bstats
struct net_rate_estimator __rcu **rate_est: 速率估算器統計資訊
spinlock_t *lock: 統計資訊和控制路徑的鎖
bool running: 如果 bstats 表示正在執行的 qdisc，則為 true，因此 bstats 的內部值可能會在基本讀取期間發生變化。僅在 bstats_cpu 為 NULL 時使用
struct nlattr *opt: 速率估算器配置 TLV

描述

建立一個新的速率估算器，其中 bstats 作為源，rate_est 作為目標。建立一個新的計時器，其間隔在配置 TLV 中指定。在每個間隔時，將從 bstats 讀取最新的統計資訊，並且估計速率將儲存在 rate_est 中，在此期間會獲取統計資訊鎖。

成功時返回 0，或者返回一個負的錯誤程式碼。

void gen_kill_estimator(struct net_rate_estimator __rcu **rate_est)¶: 刪除一個速率估算器

引數

struct net_rate_estimator __rcu **rate_est: 速率估算器

描述

刪除速率估算器。

int gen_replace_estimator(struct gnet_stats_basic_sync *bstats, struct gnet_stats_basic_sync __percpu *cpu_bstats, struct net_rate_estimator __rcu **rate_est, spinlock_t *lock, bool running, struct nlattr *opt)¶: 替換速率估算器配置

引數

struct gnet_stats_basic_sync *bstats: 基本統計資訊
struct gnet_stats_basic_sync __percpu *cpu_bstats: 每個 CPU 的 bstats
struct net_rate_estimator __rcu **rate_est: 速率估算器統計資訊
spinlock_t *lock: 統計資訊和控制路徑的鎖
bool running: 如果 bstats 表示正在執行的 qdisc，則為 true，因此 bstats 的內部值可能會在基本讀取期間發生變化。僅在 cpu_bstats 為 NULL 時使用
struct nlattr *opt: 速率估算器配置 TLV

描述

透過呼叫 gen_kill_estimator() 和 gen_new_estimator() 替換速率估算器的配置。

成功時返回 0，或者返回一個負的錯誤程式碼。

bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est)¶: 測試估算器當前是否正在使用

引數

struct net_rate_estimator __rcu **rate_est: 速率估算器

描述

如果估算器處於活動狀態，則返回 true，否則返回 false。

SUN RPC 子系統¶

__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)¶: 編碼固定長度的不透明資料

引數

__be32 *p: 指向 XDR 緩衝區中當前位置的指標。
const void *ptr: 指向要編碼的資料的指標（或 NULL）
unsigned int nbytes: 資料大小。

描述

將 ptr 處長度為 nbytes 的資料陣列複製到 p 位置的 XDR 緩衝區，然後透過用零位元組填充來對齊到下一個 32 位邊界（參見 RFC1832）。返回更新後的當前 XDR 緩衝區位置

注意

如果 ptr 為 NULL，則僅執行填充。

__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)¶: 編碼可變長度的不透明資料

引數

__be32 *p: 指向 XDR 緩衝區中當前位置的指標。
const void *ptr: 指向要編碼的資料的指標（或 NULL）
unsigned int nbytes: 資料大小。

描述

返回更新後的當前 XDR 緩衝區位置

void xdr_terminate_string(const struct xdr_buf *buf, const u32 len)¶: ‘0’-終止駐留在 xdr_buf 中的字串

引數

const struct xdr_buf *buf: 字串所在的 XDR 緩衝區
const u32 len: 字串的長度（以位元組為單位）

unsigned int xdr_buf_to_bvec(struct bio_vec *bvec, unsigned int bvec_size, const struct xdr_buf *xdr)¶: 將 xdr_buf 的元件複製到 bio_vec 陣列中

引數

struct bio_vec *bvec: 要填充的 bio_vec 陣列
unsigned int bvec_size: bio_vec 的元素計數
const struct xdr_buf *xdr: 要複製的 xdr_buf

描述

返回 bvec 中消耗的條目數。

void xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset, struct page **pages, unsigned int base, unsigned int len)¶: 為大型回覆準備接收緩衝區

引數

struct xdr_buf *xdr: 回覆將放入的 xdr_buf
unsigned int offset: 資料負載預計開始的偏移量（以位元組為單位）
struct page **pages: struct page 指標的向量
unsigned int base: 接收應該開始的第一頁中的偏移量（以位元組為單位）
unsigned int len: 預計的上層資料負載大小（以位元組為單位）

void _copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)¶

引數

char *p: 指向目標的指標
struct page **pages: 頁面陣列
size_t pgbase: 源資料的偏移量
size_t len: 長度

描述

將資料從頁面陣列複製到任意記憶體位置。假定複製是非重疊的。

unsigned int xdr_stream_pos(const struct xdr_stream *xdr)¶: 返回從 xdr_stream 開始的當前偏移量

引數

const struct xdr_stream *xdr: 指向 struct xdr_stream 的指標

unsigned int xdr_page_pos(const struct xdr_stream *xdr)¶: 返回從 xdr 頁面的開始的當前偏移量

引數

const struct xdr_stream *xdr: 指向 struct xdr_stream 的指標

void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p, struct rpc_rqst *rqst)¶: 初始化一個 struct xdr_stream 以傳送資料。

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
struct xdr_buf *buf: 指向用於編碼資料的 XDR 緩衝區的指標
__be32 *p: XDR 緩衝區內的當前指標
struct rpc_rqst *rqst: 指向控制 rpc_rqst 的指標，用於除錯

注意

目前，RPC 客戶端只在 xdr_buf 的頭部 kvec 中傳遞我們: 暫存緩衝區的大小。以前，這意味著我們需要在編碼資料後呼叫 xdr_adjust_iovec()。使用新的方案，xdr_stream 管理緩衝區長度的詳細資訊，並負責為我們調整 kvec 長度。

void xdr_init_encode_pages(struct xdr_stream *xdr, struct xdr_buf *buf, struct page **pages, struct rpc_rqst *rqst)¶: 初始化一個 xdr_stream 用於編碼到頁面中

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
struct xdr_buf *buf: 指向用於編碼資料的 XDR 緩衝區的指標
struct page **pages: 要解碼到的頁面列表
struct rpc_rqst *rqst: 指向控制 rpc_rqst 的指標，用於除錯

void __xdr_commit_encode(struct xdr_stream *xdr)¶: 確保所有資料都寫入緩衝區

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標

描述

我們透過給呼叫者一個臨時的寫入位置來處理跨頁面邊界的編碼，然後在以後將資料複製到適當的位置；xdr_commit_encode 就是做這個複製的。

通常呼叫者不需要直接呼叫它，因為下面的 xdr_reserve_space 會完成它。但是可能需要在編碼結束時顯式呼叫，或者在任何時候可能讀取 xdr_buf 資料時進行顯式呼叫。

__be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)¶: 保留用於傳送的緩衝區空間

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
size_t nbytes: 要保留的位元組數

描述

檢查我們是否有足夠的緩衝區空間來編碼更多“nbytes”位元組的資料。如果是，則更新 xdr_buf 總長度，並調整當前 kvec 的長度。

返回的指標僅在下次呼叫 xdr_reserve_space() 或 xdr_commit_encode() 在 xdr 上呼叫之前有效。此 API 的當前實現保證為 4 位元組資料項保留的空間在 xdr 被銷燬之前仍然有效，但這在未來可能並非總是如此。

int xdr_reserve_space_vec(struct xdr_stream *xdr, size_t nbytes)¶: 為傳送保留大量緩衝區空間

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
size_t nbytes: 要保留的位元組數

描述

傳遞給 xdr_reserve_space() 的 size 引數是基於當前頁面中剩餘的位元組數確定的，以避免在呼叫 xdr_commit_encode() 時使 iov_base 指標無效。

返回值: 0：成功 -EMSGSIZE：在 xdr 中沒有足夠的可用空間

void xdr_truncate_encode(struct xdr_stream *xdr, size_t len)¶: 截斷一個編碼緩衝區

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
size_t len: 緩衝區的新長度

描述

截斷 xdr 流，使 xdr->buf->len == len，xdr->p 指向從緩衝區起始位置偏移 len 處，並且頭部、尾部和頁面長度都會被調整以對應。

如果這意味著將 xdr->p 移動到不同的緩衝區，我們假設結束指標應該設定為當前頁面的結尾，除非在頭部緩衝區的情況下，我們假設頭部緩衝區的當前長度表示可用緩衝區的結尾。

這不安全地用於已經有內聯頁面快取頁面的緩衝區（如在零複製伺服器讀取回復中），除了從尾部中的一個位置截斷到另一個位置的簡單情況。

void xdr_truncate_decode(struct xdr_stream *xdr, size_t len)¶: 截斷一個解碼流

引數

struct xdr_stream *xdr: 指向 struct xdr_stream 的指標
size_t len: 要刪除的位元組數

int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen)¶: 減少可用緩衝區空間

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
int newbuflen: 新的最大可用位元組數

描述

調整我們對緩衝區中可用空間的想法。如果我們在緩衝區中已經使用了太多空間，則返回 -1。如果可用空間已經小於 newbuflen，則返回 0 並且不執行任何操作。否則，將 xdr->buf->buflen 調整為 newbuflen，並確保 xdr->end 設定為距離緩衝區起始位置最多 offset newbuflen 處。

void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base, unsigned int len)¶: 將頁面列表插入 XDR 緩衝區以進行傳送

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
struct page **pages: 要插入的頁面陣列
unsigned int base: pages 中第一個資料位元組的起始偏移量
unsigned int len: pages 中要插入的資料位元組數

描述

在新增 pages 後，尾部 iovec 被例項化，指向頭部緩衝區的結尾，並且流被設定為將後續項編碼到尾部中。

void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p, struct rpc_rqst *rqst)¶: 初始化一個 xdr_stream 以解碼資料。

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
struct xdr_buf *buf: 指向要解碼資料的 XDR 緩衝區的指標
__be32 *p: XDR 緩衝區內的當前指標
struct rpc_rqst *rqst: 指向控制 rpc_rqst 的指標，用於除錯

void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf, struct page **pages, unsigned int len)¶: 初始化一個 xdr_stream 以解碼到頁面中

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
struct xdr_buf *buf: 指向要解碼資料的 XDR 緩衝區的指標
struct page **pages: 要解碼到的頁面列表
unsigned int len: 頁面中緩衝區的長度（以位元組為單位）

void xdr_finish_decode(struct xdr_stream *xdr)¶: 在解碼資料後清理 xdr_stream。

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標

__be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)¶: 檢索要解碼的 XDR 資料

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
size_t nbytes: 要解碼的資料位元組數

描述

檢查輸入緩衝區是否足夠長，以使我們能夠從當前位置開始解碼更多“nbytes”位元組的資料。如果是，則返回當前指標，然後更新當前指標位置。

unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)¶: 將基於頁面的 XDR 資料對齊到當前指標位置

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
unsigned int len: 頁面資料的位元組數

描述

將超出當前指標位置的資料從 XDR head[] 緩衝區移動到頁面列表中。超出當前位置 + len 位元組的任何資料都會被移動到 XDR tail[] 中。然後將 xdr_stream 當前位置移動到該資料之後，以對齊到尾部中的下一個 XDR 物件。

返回現在包含在頁面中的 XDR 編碼位元組數

void xdr_set_pagelen(struct xdr_stream *xdr, unsigned int len)¶: 設定 XDR 頁面的長度

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
unsigned int len: XDR 頁面資料的新長度

描述

透過將 pagelen 設定為 len 位元組來增長或縮小 xdr 頁面的長度。當收縮時，任何額外的資料都會被移動到 buf->tail 中，而當增長時，任何超出當前指標的資料都會被移動到尾部中。

如果操作成功，則返回 True，否則返回 False。

void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)¶: 從 XDR 頁面解碼資料

引數

struct xdr_stream *xdr: 指向 xdr_stream 結構的指標
unsigned int len: 頁面資料的位元組數

描述

將超出當前指標位置的資料從 XDR head[] 緩衝區移動到頁面列表中。超出當前位置 + “len” 位元組的任何資料都會被移動到 XDR tail[] 中。然後將當前指標重新定位到第一個 XDR 頁面的開頭。

int xdr_buf_subsegment(const struct xdr_buf *buf, struct xdr_buf *subbuf, unsigned int base, unsigned int len)¶: 將 subbuf 設定為 buf 的一部分

引數

const struct xdr_buf *buf: 一個 xdr 緩衝區
struct xdr_buf *subbuf: 結果緩衝區
unsigned int base: 範圍的起始位元組
unsigned int len: 範圍的長度（以位元組為單位）

描述

將 subbuf 設定為一個 xdr 緩衝區，表示從偏移量 base 開始，長度為 len 的 buf 的一部分。

buf 和 subbuf 可以是指向同一個 struct xdr_buf 的指標。

如果 base 或 length 超出範圍，則返回 -1。

bool xdr_stream_subsegment(struct xdr_stream *xdr, struct xdr_buf *subbuf, unsigned int nbytes)¶: 將 subbuf 設定為 xdr 的一部分

引數

struct xdr_stream *xdr: 一個設定為解碼的 xdr_stream
struct xdr_buf *subbuf: 結果緩衝區
unsigned int nbytes: 要提取的 xdr 的長度（以位元組為單位）

描述

設定 subbuf 以表示 xdr 的一部分。該部分從 xdr 中的當前偏移量開始，並延伸 nbytes 的長度。如果成功，xdr 將前進到該部分之後的下一個 XDR 資料項。

返回值: true：subbuf 已被初始化，並且 xdr 已被前進。 false：發生了邊界錯誤

unsigned int xdr_stream_move_subsegment(struct xdr_stream *xdr, unsigned int offset, unsigned int target, unsigned int length)¶: 將流的一部分移動到另一個位置

引數

struct xdr_stream *xdr: 源 xdr_stream
unsigned int offset: 段的源偏移量
unsigned int target: 段的目標偏移量
unsigned int length: 要移動的位元組數

描述

將 length 個位元組從 xdr_stream 中的 offset 移動到 target，覆蓋其空間中的任何內容。返回段中的位元組數。

unsigned int xdr_stream_zero(struct xdr_stream *xdr, unsigned int offset, unsigned int length)¶: 將 xdr_stream 的一部分清零

引數

struct xdr_stream *xdr: 要清零的 xdr_stream
unsigned int offset: 流中的起始點
unsigned int length: 要清零的位元組數

void xdr_buf_trim(struct xdr_buf *buf, unsigned int len)¶: 從“buf”的末尾刪除最多“len”個位元組

引數

struct xdr_buf *buf: 要修剪的 buf
unsigned int len: 要減少“buf”的位元組數

描述

透過修復長度，按給定的位元組數修剪 xdr_buf。請注意，如果 xdr_buf 太小，或者（例如）它都在頭部並且解析器已經讀入得太深，我們可能會修剪少於該數量。

ssize_t xdr_stream_decode_opaque(struct xdr_stream *xdr, void *ptr, size_t size)¶: 解碼可變長度不透明資料

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
void *ptr: 儲存不透明資料的位置
size_t size: 儲存緩衝區 ptr 的大小

描述

返回值: 成功時，返回儲存在 *ptr 中的物件的大小 -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 在儲存緩衝區 ptr 溢位時

ssize_t xdr_stream_decode_opaque_dup(struct xdr_stream *xdr, void **ptr, size_t maxlen, gfp_t gfp_flags)¶: 解碼並複製可變長度不透明資料

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
void **ptr: 儲存指向不透明資料的指標的位置
size_t maxlen: 最大可接受的物件大小
gfp_t gfp_flags: 要使用的 GFP 掩碼

描述

返回值: 成功時，返回儲存在 *ptr 中的物件的大小 -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 如果物件的大小超過 maxlen -ENOMEM 在記憶體分配失敗時

ssize_t xdr_stream_decode_string(struct xdr_stream *xdr, char *str, size_t size)¶: 解碼可變長度字串

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
char *str: 儲存字串的位置
size_t size: 儲存緩衝區 str 的大小

描述

返回值: 成功時，返回儲存在 *str 中的以 NUL 結尾的字串的長度 -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 在儲存緩衝區 str 溢位時

ssize_t xdr_stream_decode_string_dup(struct xdr_stream *xdr, char **str, size_t maxlen, gfp_t gfp_flags)¶: 解碼並複製可變長度字串

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
char **str: 儲存指向字串的指標的位置
size_t maxlen: 最大可接受的字串長度
gfp_t gfp_flags: 要使用的 GFP 掩碼

描述

返回值: 成功時，返回儲存在 *ptr 中的以 NUL 結尾的字串的長度 -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 如果字串的大小超過 maxlen -ENOMEM 在記憶體分配失敗時

ssize_t xdr_stream_decode_opaque_auth(struct xdr_stream *xdr, u32 *flavor, void **body, unsigned int *body_len)¶: 解碼 struct opaque_auth (RFC5531 S8.2)

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
u32 *flavor: 儲存解碼後的 flavor 的位置
void **body: 儲存解碼後的 body 的位置
unsigned int *body_len: 儲存解碼後的 body 的長度的位置

描述

返回值: 成功時，返回消耗的緩衝區位元組數 -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 如果 body 欄位的解碼大小超過 400 個八位位元組

ssize_t xdr_stream_encode_opaque_auth(struct xdr_stream *xdr, u32 flavor, void *body, unsigned int body_len)¶: 編碼 struct opaque_auth (RFC5531 S8.2)

引數

struct xdr_stream *xdr: 指向 xdr_stream 的指標
u32 flavor: 要編碼的驗證器 flavor
void *body: 要編碼的 body 的內容
unsigned int body_len: 要編碼的 body 的長度

描述

返回值: 成功時，返回消耗的 XDR 緩衝區的長度（以位元組為單位） -EBADMSG 在 XDR 緩衝區溢位時 -EMSGSIZE 如果 body 的大小超過 400 個八位位元組

int svc_reg_xprt_class(struct svc_xprt_class *xcl)¶: 註冊伺服器端 RPC 傳輸類

引數

struct svc_xprt_class *xcl: 要註冊的新傳輸類

描述

成功時返回零；否則返回負 errno。

void svc_unreg_xprt_class(struct svc_xprt_class *xcl)¶: 登出伺服器端 RPC 傳輸類

引數

struct svc_xprt_class *xcl: 要登出的傳輸類

void svc_xprt_deferred_close(struct svc_xprt *xprt)¶: 關閉傳輸

引數

struct svc_xprt *xprt: 傳輸例項

描述

用於需要在將關閉傳輸的工作推遲到 nfsd 執行緒的上下文中。

void svc_xprt_received(struct svc_xprt *xprt)¶: 啟動下一個接收器執行緒

引數

struct svc_xprt *xprt: 控制傳輸

描述

呼叫者必須持有 XPT_BUSY 位，並且此後不得觸控傳輸資料。

注意

僅當讀取嘗試發現沒有（或不足夠的）資料時，XPT_DATA 才會清除。

int svc_xprt_create_from_sa(struct svc_serv *serv, const char *xprt_name, struct net *net, struct sockaddr *sap, int flags, const struct cred *cred)¶: 從套接字地址向 serv 新增新的監聽器

引數

struct svc_serv *serv: 目標 RPC 服務
const char *xprt_name: 傳輸類名稱
struct net *net: 網路名稱空間
struct sockaddr *sap: 套接字地址指標
int flags: SVC_SOCK 標誌
const struct cred *cred: 繫結到此傳輸的憑據

描述

成功時返回本地 xprt 埠，失敗時返回 -EPROTONOSUPPORT

int svc_xprt_create(struct svc_serv *serv, const char *xprt_name, struct net *net, const int family, const unsigned short port, int flags, const struct cred *cred)¶: 向 serv 新增新的監聽器

引數

struct svc_serv *serv: 目標 RPC 服務
const char *xprt_name: 傳輸類名稱
struct net *net: 網路名稱空間
const int family: 網路地址族
const unsigned short port: 監聽器埠
int flags: SVC_SOCK 標誌
const struct cred *cred: 繫結到此傳輸的憑據

描述

成功時返回本地 xprt 埠，失敗時返回 -EPROTONOSUPPORT

char *svc_print_addr(struct svc_rqst *rqstp, char *buf, size_t len)¶: 格式化 rq_addr 欄位以進行列印

引數

struct svc_rqst *rqstp: 包含要列印的地址的 svc_rqst 結構體
char *buf: 格式化地址的目標緩衝區
size_t len: 目標緩衝區的長度

void svc_xprt_enqueue(struct svc_xprt *xprt)¶: 將傳輸排隊到空閒的 nfsd 執行緒上

引數

struct svc_xprt *xprt: 具有待處理資料的傳輸

void svc_reserve(struct svc_rqst *rqstp, int space)¶: 更改為請求保留的回覆空間。

引數

struct svc_rqst *rqstp: 有問題的請求
int space: 要保留的新最大空間

描述

每個請求都會在傳輸的輸出佇列上保留一些空間，以確保回覆適合。此函式將保留空間減少為已使用的空間量，加上 space。

void svc_wake_up(struct svc_serv *serv)¶: 喚醒服務執行緒以進行非傳輸工作

引數

struct svc_serv *serv: RPC 服務

描述

一些 svc_serv 會有一些臨時工作要做，即使在沒有 xprt 等待服務時也是如此。此函式用於“啟動”其中一項服務中的任務，以便它可以喚醒並完成該工作。請注意，我們只關注池 0，因為我們不需要為此目的喚醒多個執行緒。

void svc_recv(struct svc_rqst *rqstp)¶: 接收並處理任何傳輸上的下一個請求

引數

struct svc_rqst *rqstp: 空閒的 RPC 服務執行緒

描述

此程式碼經過精心組織，不會觸及共享 svc_serv 結構體中的任何快取行，僅觸及本地 svc_pool 中的快取行。

void svc_xprt_close(struct svc_xprt *xprt)¶: 關閉客戶端連線

引數

struct svc_xprt *xprt: 要斷開連線的傳輸

void svc_xprt_destroy_all(struct svc_serv *serv, struct net *net)¶: 銷燬與 serv 關聯的傳輸

引數

struct svc_serv *serv: 要關閉的 RPC 服務
struct net *net: 目標網路名稱空間

描述

伺服器執行緒可能仍在執行（尤其是在服務仍在其他網路名稱空間中執行時）。

因此，我們關閉套接字的方式與在執行的伺服器上相同，方法是設定 XPT_CLOSE，排隊，然後讓一個執行緒選擇它來執行關閉。如果沒有其他此類執行緒，則執行執行緒 svc_clean_up_xprts() 執行伺服器主事件迴圈的簡單版本，並且在有其他執行緒的情況下，我們可能需要等待一段時間，然後再次檢查它們是否已完成。

struct svc_xprt *svc_find_listener(struct svc_serv *serv, const char *xcl_name, struct net *net, const struct sockaddr *sa)¶: 查詢 RPC 傳輸例項

引數

struct svc_serv *serv: 要搜尋的 svc_serv 的指標
const char *xcl_name: 包含傳輸類名稱的 C 字串
struct net *net: 所有者網路指標
const struct sockaddr *sa: 包含地址的 sockaddr

描述

返回用於接受來自指定傳輸類的連線/對等流量並匹配 sockaddr 的端點的傳輸例項指標。

struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name, struct net *net, const sa_family_t af, const unsigned short port)¶: 查詢 RPC 傳輸例項

引數

struct svc_serv *serv: 要搜尋的 svc_serv 的指標
const char *xcl_name: 包含傳輸類名稱的 C 字串
struct net *net: 所有者網路指標
const sa_family_t af: 傳輸本地地址的地址族
const unsigned short port: 傳輸的 IP 埠號

描述

返回用於接受來自指定傳輸類、地址族和埠的連線/對等流量的端點的傳輸例項指標。

為地址族或埠指定 0 有效地是一個萬用字元，將導致匹配服務列表中具有匹配類名稱的第一個傳輸。

int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen)¶: 格式化帶有傳輸名稱列表的緩衝區

引數

struct svc_serv *serv: RPC 服務的指標
char *buf: 要填充的緩衝區的指標
const int buflen: 要填充的緩衝區的長度

描述

用包含傳輸名稱列表的字串填充 buf，每個名稱都以“n”結尾。

成功時返回填充字串的正長度；否則，如果發生錯誤，則返回負 errno 值。

int xprt_register_transport(struct xprt_class *transport)¶: 註冊傳輸實現

引數

struct xprt_class *transport: 要註冊的傳輸

描述

如果傳輸實現作為核心模組載入，則它可以呼叫此介面以使自身為 RPC 客戶端所知。

返回 skb dst_entry

0：傳輸已成功註冊 -EEXIST：傳輸已註冊 -EINVAL：傳輸模組正在解除安裝

int xprt_unregister_transport(struct xprt_class *transport)¶: 取消註冊傳輸實現

引數

struct xprt_class *transport: 要取消註冊的傳輸

返回 skb dst_entry

0：傳輸已成功取消註冊 -ENOENT：傳輸從未註冊

int xprt_find_transport_ident(const char *netid)¶: 將 netid 轉換為傳輸識別符號

引數

const char *netid: 要載入的傳輸

返回 skb dst_entry

> 0：傳輸識別符號 -ENOENT：傳輸模組不可用

int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task)¶: 序列化對傳輸的寫入訪問

引數

struct rpc_xprt *xprt: 目標傳輸的指標
struct rpc_task *task: 請求訪問傳輸的任務

描述

這可以防止混合單獨請求的有效負載，並防止傳輸連線與寫入發生衝突。不提供擁塞控制。

void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)¶: 允許其他請求使用傳輸

引數

struct rpc_xprt *xprt: 傳輸具有其他可能正在等待的任務
struct rpc_task *task: 正在釋放對傳輸的訪問的任務

描述

請注意，“task”可以為 NULL。不提供擁塞控制。

void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)¶: 允許其他請求使用傳輸

引數

struct rpc_xprt *xprt: 傳輸具有其他可能正在等待的任務
struct rpc_task *task: 正在釋放對傳輸的訪問的任務

描述

請注意，“task”可以為 NULL。如果傳輸的擁塞視窗允許，則會喚醒另一個任務以使用傳輸。

bool xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)¶: 請求擁塞控制信用

引數

struct rpc_xprt *xprt: 傳輸的指標
struct rpc_rqst *req: RPC 請求的指標

描述

對於需要擁塞控制的傳輸很有用。

void xprt_release_rqst_cong(struct rpc_task *task)¶: 請求完成時的內務管理

引數

struct rpc_task *task: 最近完成的 RPC 請求

描述

對於需要擁塞控制的傳輸很有用。

void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result)¶: 調整傳輸擁塞視窗

引數

struct rpc_xprt *xprt: xprt 的指標
struct rpc_task *task: 最近完成的 RPC 請求，用於調整視窗
int result: 已完成 RPC 請求的結果程式碼

描述

傳輸程式碼維護對最大未完成 RPC 請求數的估計，使用 44BSD 中實現的擁塞避免的平滑版本。這基本上是 Van Jacobson 擁塞演算法：如果發生重傳，則擁塞視窗減半；否則，當

收到回覆，並且

全部請求已完成，並且

擁塞視窗最近沒有更新時，它會遞增 1/cwnd。

void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status)¶: 喚醒傳輸的掛起佇列上的所有任務

引數

struct rpc_xprt *xprt: 具有等待任務的傳輸
int status: 在喚醒每個任務之前要植入的結果程式碼

void xprt_wait_for_buffer_space(struct rpc_xprt *xprt)¶: 等待傳輸輸出緩衝區清除

引數

struct rpc_xprt *xprt: 傳輸

描述

請注意，我們僅為 RPC_IS_SOFT() 的情況設定計時器，因為我們通常不想由於不完整的 RPC 呼叫傳輸而強制套接字斷開連線。

bool xprt_write_space(struct rpc_xprt *xprt)¶: 喚醒等待傳輸輸出緩衝區空間的任務

引數

struct rpc_xprt *xprt: 具有等待任務的傳輸

描述

可以在軟 IRQ 上下文中呼叫，因此 xprt_write_space 永遠不會休眠。

void xprt_disconnect_done(struct rpc_xprt *xprt)¶: 將傳輸標記為已斷開連線

引數

struct rpc_xprt *xprt: 要標記為斷開連線的傳輸

void xprt_force_disconnect(struct rpc_xprt *xprt)¶: 強制傳輸斷開連線

引數

struct rpc_xprt *xprt: 要斷開連線的傳輸

unsigned long xprt_reconnect_delay(const struct rpc_xprt *xprt)¶: 計算安排連線之前的等待時間

引數

const struct rpc_xprt *xprt: 傳輸例項

void xprt_reconnect_backoff(struct rpc_xprt *xprt, unsigned long init_to)¶: 計算新的重新建立超時

引數

struct rpc_xprt *xprt: 傳輸例項
unsigned long init_to: 初始重新建立超時

struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)¶: 查詢與 XID 對應的 RPC 請求

引數

struct rpc_xprt *xprt: 傳輸原始請求的傳輸
__be32 xid: 傳入回覆的 RPC XID

描述

呼叫方持有 xprt->queue_lock。

void xprt_pin_rqst(struct rpc_rqst *req)¶: 將請求固定在傳輸接收列表上

引數

struct rpc_rqst *req: 要固定的請求

描述

呼叫方必須確保這與對 xprt_lookup_rqst() 的呼叫是原子的，因此應持有 xprt->queue_lock。

void xprt_unpin_rqst(struct rpc_rqst *req)¶: 取消固定傳輸接收列表上的請求

引數

struct rpc_rqst *req: 要固定的請求

描述

呼叫方應持有 xprt->queue_lock。

void xprt_update_rtt(struct rpc_task *task)¶: 更新 RPC RTT 統計資訊

引數

struct rpc_task *task: 最近完成的 RPC 請求

描述

呼叫方持有 xprt->queue_lock。

void xprt_complete_rqst(struct rpc_task *task, int copied)¶: 在回覆處理完成時呼叫

引數

struct rpc_task *task: 最近完成的 RPC 請求
int copied: 從傳輸接收的實際位元組數

描述

呼叫方持有 xprt->queue_lock。

void xprt_wait_for_reply_request_def(struct rpc_task *task)¶: 等待回覆

引數

struct rpc_task *task: rpc_task 的指標

描述

根據傳輸的預設超時引數設定請求的重傳超時。由不根據往返時間估計調整重傳超時的傳輸使用，並將任務置於掛起佇列中睡眠。

void xprt_wait_for_reply_request_rtt(struct rpc_task *task)¶: 使用 RTT 估計器等待回覆

引數

struct rpc_task *task: rpc_task 的指標

描述

使用 RTT 估計器設定請求的重傳超時，並將任務置於掛起佇列中睡眠。

struct rpc_xprt *xprt_get(struct rpc_xprt *xprt)¶: 返回對 RPC 傳輸的引用。

引數

struct rpc_xprt *xprt: 傳輸的指標

void xprt_put(struct rpc_xprt *xprt)¶: 釋放對 RPC 傳輸的引用。

引數

struct rpc_xprt *xprt: 傳輸的指標

void rpc_wake_up(struct rpc_wait_queue *queue)¶: 喚醒所有 rpc_task

引數

struct rpc_wait_queue *queue: 任務在其上睡眠的 rpc_wait_queue

描述

獲取 queue->lock

void rpc_wake_up_status(struct rpc_wait_queue *queue, int status)¶: 喚醒所有 rpc_task 並設定其狀態值。

引數

struct rpc_wait_queue *queue: 任務在其上睡眠的 rpc_wait_queue
int status: 要設定的狀態值

描述

獲取 queue->lock

int rpc_malloc(struct rpc_task *task)¶: 分配 RPC 緩衝區資源

引數

struct rpc_task *task: RPC 任務

描述

分配一個記憶體區域，該區域在此任務使用的 RPC 呼叫和 RPC 回覆之間拆分。當此 RPC 停用時，透過呼叫 rpc_free 釋放記憶體。

為了防止 rpciod 掛起，此分配器從不休眠，如果請求無法立即處理，則返回 -ENOMEM 並禁止警告。呼叫者可以安排以對 rpciod 安全的方式休眠。

大多數請求都是“小”請求（小於 2KiB），可以從記憶體池中處理，從而確保 NFS 的讀取和寫入始終可以進行，並且這些緩衝區具有良好的引用區域性性。

void rpc_free(struct rpc_task *task)¶: 釋放透過 rpc_malloc 分配的 RPC 緩衝區資源

引數

struct rpc_task *task: RPC 任務

int csum_partial_copy_to_xdr(struct xdr_buf *xdr, struct sk_buff *skb)¶: 校驗和並複製資料

引數

struct xdr_buf *xdr: 目標 XDR 緩衝區
設定 skb dst: 源 skb

描述

我們已經設定好了，可以並行執行 UDP 資料包的校驗和以及複製到 RPC 客戶端 iovec 中的操作。 -DaveM

struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt)¶: 分配一個 rpc_iostats 結構

引數

struct rpc_clnt *clnt: RPC 程式、版本和 xprt

void rpc_free_iostats(struct rpc_iostats *stats)¶: 釋放一個 rpc_iostats 結構

引數

struct rpc_iostats *stats: 要銷燬的 rpc_iostats 結構

void rpc_count_iostats_metrics(const struct rpc_task *task, struct rpc_iostats *op_metrics)¶: 統計每個任務的統計資訊

引數

const struct rpc_task *task: 已完成的 rpc_task
struct rpc_iostats *op_metrics: OP 的統計結構，它將累積來自 task 的統計資訊

void rpc_count_iostats(const struct rpc_task *task, struct rpc_iostats *stats)¶: 統計每個任務的統計資訊

引數

const struct rpc_task *task: 已完成的 rpc_task
struct rpc_iostats *stats: 統計結構陣列

描述

使用來自 task 的 statidx

int rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)¶: 將 upcall 訊息排隊到使用者空間

引數

struct rpc_pipe *pipe: 在其上排隊給定訊息的 upcall 管道
struct rpc_pipe_msg *msg: 要排隊的訊息

描述

使用 rpc_mkpipe() 建立的 inode 呼叫以排隊 upcall。然後，使用者空間程序可以透過對此 inode 的開啟檔案執行讀取來稍後讀取 upcall。呼叫者有責任適當地初始化 msg 的欄位（除了 msg->list 之外）。

struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name, void *private, struct rpc_pipe *pipe)¶: 為核心<->使用者空間通訊建立一個 rpc_pipefs 檔案

引數

struct dentry *parent: 要在其中建立新“管道”的目錄的 dentry
const char *name: 管道的名稱
void *private: 與管道關聯的私有資料，供呼叫者使用
struct rpc_pipe *pipe: rpc_pipe 包含輸入引數

描述

透過呼叫 rpc_queue_upcall() 使資料可供使用者空間讀取。實際讀取將導致呼叫 ops->upcall，它將被呼叫檔案指標、訊息和要複製到的使用者空間緩衝區。

寫入可以隨時進行，並且不一定必須是對 upcall 的響應。它們將導致呼叫 msg->downcall。

此處傳遞的 private 引數將可用於來自檔案指標的所有這些方法，透過 RPC_I(file_inode(file))->private。

int rpc_unlink(struct dentry *dentry)¶: 刪除管道

引數

struct dentry *dentry: 管道的 dentry，如從 rpc_mkpipe 返回

描述

在此呼叫之後，查詢將不再找到管道，並且任何使用管道的先前開啟嘗試進行讀取或寫入將返回 -EPIPE。

void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head *pdh)¶: 初始化一個 struct rpc_pipe_dir_head

引數

struct rpc_pipe_dir_head *pdh: 指向 struct rpc_pipe_dir_head 的指標

void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object *pdo, const struct rpc_pipe_dir_object_ops *pdo_ops, void *pdo_data)¶: 初始化一個 struct rpc_pipe_dir_object

引數

struct rpc_pipe_dir_object *pdo: 指向 struct rpc_pipe_dir_object 的指標
const struct rpc_pipe_dir_object_ops *pdo_ops: 指向 const struct rpc_pipe_dir_object_ops 的指標
void *pdo_data: 指向呼叫者定義的資料的指標

int rpc_add_pipe_dir_object(struct net *net, struct rpc_pipe_dir_head *pdh, struct rpc_pipe_dir_object *pdo)¶: 將 rpc_pipe_dir_object 關聯到目錄

引數

struct net *net: 指向 struct net 的指標
struct rpc_pipe_dir_head *pdh: 指向 struct rpc_pipe_dir_head 的指標
struct rpc_pipe_dir_object *pdo: 指向 struct rpc_pipe_dir_object 的指標

void rpc_remove_pipe_dir_object(struct net *net, struct rpc_pipe_dir_head *pdh, struct rpc_pipe_dir_object *pdo)¶: 從目錄中刪除一個 rpc_pipe_dir_object

引數

struct net *net: 指向 struct net 的指標
struct rpc_pipe_dir_head *pdh: 指向 struct rpc_pipe_dir_head 的指標
struct rpc_pipe_dir_object *pdo: 指向 struct rpc_pipe_dir_object 的指標

struct rpc_pipe_dir_object *rpc_find_or_alloc_pipe_dir_object(struct net *net, struct rpc_pipe_dir_head *pdh, int (*match)(struct rpc_pipe_dir_object*, void*), struct rpc_pipe_dir_object *(*alloc)(void*), void *data)¶

引數

struct net *net: 指向 struct net 的指標
struct rpc_pipe_dir_head *pdh: 指向 struct rpc_pipe_dir_head 的指標
int (*match)(struct rpc_pipe_dir_object *, void *): 將 struct rpc_pipe_dir_object 與資料匹配
struct rpc_pipe_dir_object *(*alloc)(void *): 分配一個新的 struct rpc_pipe_dir_object
void *data: 用於 match() 和 alloc() 的使用者定義資料

void rpcb_getport_async(struct rpc_task *task)¶: 在給定主機上獲取給定 RPC 服務的埠

引數

struct rpc_task *task: 正在等待 portmapper 請求的任務

描述

可以為正在進行的 RPC 請求呼叫此函式，並且可以在非同步 (rpciod) 上下文中使用。

struct rpc_clnt *rpc_create(struct rpc_create_args *args)¶: 透過一次呼叫建立一個 RPC 客戶端和傳輸

引數

struct rpc_create_args *args: rpc_clnt 建立引數結構

描述

建立並初始化 RPC 傳輸和 RPC 客戶端。

它可以 ping 伺服器以確定它是否已啟動，並檢視它是否支援此程式和版本。 RPC_CLNT_CREATE_NOPING 停用此行為，以便非同步任務也可以使用 rpc_create。

struct rpc_clnt *rpc_clone_client(struct rpc_clnt *clnt)¶: 克隆一個 RPC 客戶端結構

引數

struct rpc_clnt *clnt: 複製其引數的 RPC 客戶端

描述

返回一個新的 RPC 客戶端或 ERR_PTR。

struct rpc_clnt *rpc_clone_client_set_auth(struct rpc_clnt *clnt, rpc_authflavor_t flavor)¶: 克隆一個 RPC 客戶端結構並設定其身份驗證

引數

struct rpc_clnt *clnt: 複製其引數的 RPC 客戶端
rpc_authflavor_t flavor: 新客戶端的安全風格

描述

返回一個新的 RPC 客戶端或 ERR_PTR。

int rpc_switch_client_transport(struct rpc_clnt *clnt, struct xprt_create *args, const struct rpc_timeout *timeout)¶: 動態切換 RPC 傳輸

引數

struct rpc_clnt *clnt: 指向 struct rpc_clnt 的指標
struct xprt_create *args: 指向新傳輸引數的指標
const struct rpc_timeout *timeout: 指向新超時引數的指標

描述

此函式允許呼叫者切換 rpc_clnt 結構“clnt”的 RPC 傳輸，以允許其連線到映象的 NFS 伺服器，例如。它假定呼叫者已確保沒有任何活動的 RPC 任務，方法是使用某種形式的鎖定。

如果“clnt”現在正在使用新的 xprt，則返回零。否則，將返回一個負 errno，“clnt”繼續使用舊的 xprt。

int rpc_clnt_iterate_for_each_xprt(struct rpc_clnt *clnt, int (*fn)(struct rpc_clnt*, struct rpc_xprt*, void*), void *data)¶: 將函式應用於所有傳輸

引數

struct rpc_clnt *clnt: 指向客戶端的指標
int (*fn)(struct rpc_clnt *, struct rpc_xprt *, void *): 要應用的函式
void *data: 指向函式資料的 void 指標

描述

迭代當前附加到客戶端的 RPC 傳輸列表，並應用函式 fn(clnt, xprt, data)。

發生錯誤時，迭代停止，並且函式返回錯誤值。

unsigned long rpc_cancel_tasks(struct rpc_clnt *clnt, int error, bool (*fnmatch)(const struct rpc_task*, const void*), const void *data)¶: 嘗試取消一組 RPC 任務

引數

struct rpc_clnt *clnt: 指向 RPC 客戶端的指標
int error: 要設定的 RPC 任務錯誤值
bool (*fnmatch)(const struct rpc_task *, const void *): 指向選擇器函式的指標
const void *data: 使用者資料

描述

使用 fnmatch 定義要取消的一組 RPC 任務。引數 error 必須是一個負錯誤值。

struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *old, const struct rpc_program *program, u32 vers)¶: 將新 RPC 程式繫結到現有客戶端

引數

struct rpc_clnt *old: 舊的 rpc_client
const struct rpc_program *program: 要設定的 rpc 程式
u32 vers: rpc 程式版本

描述

克隆 RPC 客戶端並設定一個新的 RPC 程式。這主要用於使不同的 RPC 程式共享相同的傳輸。Sun NFSv2/v3 ACL 協議可以做到這一點。

struct rpc_task *rpc_run_task(const struct rpc_task_setup *task_setup_data)¶: 分配一個新的 RPC 任務，然後對其執行 rpc_execute

引數

const struct rpc_task_setup *task_setup_data: 指向任務初始化資料的指標

int rpc_call_sync(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags)¶: 執行同步 RPC 呼叫

引數

struct rpc_clnt *clnt: 指向 RPC 客戶端的指標
const struct rpc_message *msg: RPC 呼叫引數
int flags: RPC 呼叫標誌

int rpc_call_async(struct rpc_clnt *clnt, const struct rpc_message *msg, int flags, const struct rpc_call_ops *tk_ops, void *data)¶: 執行非同步 RPC 呼叫

引數

struct rpc_clnt *clnt: 指向 RPC 客戶端的指標
const struct rpc_message *msg: RPC 呼叫引數
int flags: RPC 呼叫標誌
const struct rpc_call_ops *tk_ops: RPC 呼叫操作
void *data: 使用者呼叫資料

void rpc_prepare_reply_pages(struct rpc_rqst *req, struct page **pages, unsigned int base, unsigned int len, unsigned int hdrsize)¶: 準備將回複數據負載接收到頁面中

引數

struct rpc_rqst *req: 要準備的 RPC 請求
struct page **pages: struct page 指標的向量
unsigned int base: 接收應該開始的第一頁中的偏移量（以位元組為單位）
unsigned int len: 預計的上層資料負載大小（以位元組為單位）
unsigned int hdrsize: 上層回覆標頭的預期大小，以 XDR 字為單位

size_t rpc_peeraddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t bufsize)¶: 從 clnt 的 xprt 中提取遠端對等地址

引數

struct rpc_clnt *clnt: RPC 客戶端結構
struct sockaddr *buf: 目標緩衝區
size_t bufsize: 目標緩衝區的長度

描述

返回儲存地址中實際的位元組數。

const char *rpc_peeraddr2str(struct rpc_clnt *clnt, enum rpc_display_format_t format)¶: 以可列印格式返回遠端對等地址

引數

struct rpc_clnt *clnt: RPC 客戶端結構
enum rpc_display_format_t format: 地址格式

描述

注意：返回指標引用的記憶體的生存期與 rpc_xprt 本身相同。只要呼叫者使用此指標，它就必須保持 RCU 讀取鎖。

int rpc_localaddr(struct rpc_clnt *clnt, struct sockaddr *buf, size_t buflen)¶: 發現 RPC 客戶端的本地端點地址

引數

struct rpc_clnt *clnt: RPC 客戶端結構
struct sockaddr *buf: 目標緩衝區
size_t buflen: 目標緩衝區的大小，以位元組為單位

描述

如果成功，則返回零並填充“buf”和“buflen”；否則，返回一個負 errno。

即使底層傳輸當前未連線，或者上層先前從未提供源地址，這也可以工作。

此函式呼叫的結果是暫時的：連續多次呼叫可能會給出不同的結果，具體取決於本地網路配置隨時間的變化方式。

struct net *rpc_net_ns(struct rpc_clnt *clnt)¶: 獲取此 RPC 客戶端的網路名稱空間

引數

struct rpc_clnt *clnt: 要查詢的 RPC 客戶端

size_t rpc_max_payload(struct rpc_clnt *clnt)¶: 獲取傳輸的最大負載大小，以位元組為單位

引數

struct rpc_clnt *clnt: 要查詢的 RPC 客戶端

描述

對於流傳輸，這是一個 RPC 記錄片段（參見 RFC 1831），因為我們尚不支援多記錄請求。對於資料報傳輸，這是 IP 資料包的大小減去 IP、UDP 和 RPC 標頭大小。

size_t rpc_max_bc_payload(struct rpc_clnt *clnt)¶: 獲取最大反向通道負載大小，以位元組為單位

引數

struct rpc_clnt *clnt: 要查詢的 RPC 客戶端

void rpc_force_rebind(struct rpc_clnt *clnt)¶: 強制傳輸檢查遠端埠是否未更改

引數

struct rpc_clnt *clnt: 客戶端重新繫結

int rpc_clnt_test_and_add_xprt(struct rpc_clnt *clnt, struct rpc_xprt_switch *xps, struct rpc_xprt *xprt, void *in_max_connect)¶: 測試並向 rpc_clnt 新增新的傳輸

引數

struct rpc_clnt *clnt: 指向 struct rpc_clnt 的指標
struct rpc_xprt_switch *xps: 指向 struct rpc_xprt_switch 的指標
struct rpc_xprt *xprt: 指標 struct rpc_xprt
void *in_max_connect: 指向傳入 xprt 傳輸的 max_connect 值的指標

int rpc_clnt_setup_test_and_add_xprt(struct rpc_clnt *clnt, struct rpc_xprt_switch *xps, struct rpc_xprt *xprt, void *data)¶

引數

struct rpc_clnt *clnt: struct rpc_clnt 獲取新的傳輸
struct rpc_xprt_switch *xps: rpc_xprt_switch 儲存新的傳輸
struct rpc_xprt *xprt: 要測試的 rpc_xprt
void *data: 一個 struct rpc_add_xprt_test 指標，它儲存測試函式和測試函式呼叫資料

描述

這是一個返回 1 的 rpc_clnt_add_xprt setup() 函式，因此: 1) 測試函式的呼叫者必須解引用 rpc_xprt_switch 和 rpc_xprt。 2) 測試函式必須呼叫 rpc_xprt_switch_add_xprt，通常在 rpc_call_done 例程中。

成功後（返回 1），測試函式將新的傳輸新增到 rpc_clnt xprt 交換機

int rpc_clnt_add_xprt(struct rpc_clnt *clnt, struct xprt_create *xprtargs, int (*setup)(struct rpc_clnt*, struct rpc_xprt_switch*, struct rpc_xprt*, void*), void *data)¶: 向 rpc_clnt 新增新的傳輸

引數

struct rpc_clnt *clnt: 指向 struct rpc_clnt 的指標
struct xprt_create *xprtargs: 指向 struct xprt_create 的指標
int (*setup)(struct rpc_clnt *, struct rpc_xprt_switch *, struct rpc_xprt *, void *): 測試和/或設定連線的回撥
void *data: 指向設定函式資料的指標

描述

使用 args 中設定的引數建立一個新的傳輸並將其新增到 clnt。如果設定了 ping，則在新增新傳輸之前測試連線是否成功。

網路裝置支援¶

驅動程式支援¶

void dev_add_pack(struct packet_type *pt)¶: 新增資料包處理程式

引數

struct packet_type *pt

資料包型別宣告

將協議處理程式新增到網路堆疊。傳遞的 packet_type 連結到核心列表，並且在從核心列表中刪除之前可能不會釋放它。

此呼叫不休眠，因此它不能保證所有正在接收資料包的 CPU 都會看到新的資料包型別（直到下一個收到的資料包）。

void __dev_remove_pack(struct packet_type *pt)¶: 刪除資料包處理程式

引數

struct packet_type *pt

資料包型別宣告

刪除先前透過 dev_add_pack() 新增到核心協議處理程式的協議處理程式。傳遞的 packet_type 將從核心列表中刪除，並且一旦此函式返回，就可以釋放或重用。

資料包型別可能仍在接收器中使用，並且必須在所有 CPU 都經過靜止狀態之後才能釋放。

void dev_remove_pack(struct packet_type *pt)¶: 刪除資料包處理程式

引數

struct packet_type *pt

資料包型別宣告

刪除先前透過 dev_add_pack() 新增到核心協議處理程式的協議處理程式。傳遞的 packet_type 將從核心列表中刪除，並且一旦此函式返回，就可以釋放或重用。

此呼叫會休眠以保證在返回後沒有 CPU 正在檢視資料包型別。

int dev_get_iflink(const struct net_device *dev)¶: 獲取介面的“iflink”值

引數

const struct net_device *dev

目標介面

指示介面連結到的 ifindex。物理介面具有相同的“ifindex”和“iflink”值。

int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)¶: 檢索隧道出口資訊。

引數

struct net_device *dev

目標介面

設定 skb dst

資料包。

為了更好地瞭解隧道流量，OVS 需要檢索資料包的出口隧道資訊。以下 API 允許使用者獲取此資訊。

struct net_device *__dev_get_by_name(struct net *net, const char *name)¶: 按名稱查詢裝置

引數

struct net *net

適用的網路名稱空間

const char *name

要查詢的名稱

按名稱查詢介面。必須在 RTNL 訊號量下呼叫。如果找到名稱，則返回指向裝置的指標。如果未找到名稱，則返回 NULL。引用計數器不會遞增，因此呼叫者必須小心鎖定。

struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)¶: 按名稱查詢裝置

引數

struct net *net: 適用的網路名稱空間
const char *name: 要查詢的名稱

描述

按名稱查詢介面。如果找到名稱，則返回指向裝置的指標。如果未找到名稱，則返回 NULL。引用計數器不會遞增，因此呼叫者必須小心鎖定。呼叫者必須持有 RCU 鎖。

struct net_device *netdev_get_by_name(struct net *net, const char *name, netdevice_tracker *tracker, gfp_t gfp)¶: 按名稱查詢裝置

引數

struct net *net

適用的網路名稱空間

const char *name

要查詢的名稱

netdevice_tracker *tracker

獲取的引用的跟蹤物件

gfp_t gfp

跟蹤器的分配標誌

按名稱查詢介面。可以從任何上下文中呼叫此函式，並且它會進行自己的鎖定。返回的控制代碼已遞增使用計數，並且呼叫者必須使用 netdev_put() 在不再需要時釋放它。如果未找到匹配的裝置，則返回 NULL。

struct net_device *__dev_get_by_index(struct net *net, int ifindex)¶: 按 ifindex 查詢裝置

引數

struct net *net

適用的網路名稱空間

int ifindex

裝置索引

按索引搜尋介面。如果未找到裝置，則返回 NULL 或指向該裝置的指標。裝置尚未增加其引用計數器，因此呼叫者必須小心鎖定。呼叫者必須持有 RTNL 訊號量。

struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)¶: 按 ifindex 查詢裝置

引數

struct net *net

適用的網路名稱空間

int ifindex

裝置索引

按索引搜尋介面。如果未找到裝置，則返回 NULL 或指向該裝置的指標。裝置尚未增加其引用計數器，因此呼叫者必須小心鎖定。呼叫者必須持有 RCU 鎖。

struct net_device *netdev_get_by_index(struct net *net, int ifindex, netdevice_tracker *tracker, gfp_t gfp)¶: 按 ifindex 查詢裝置

引數

struct net *net

適用的網路名稱空間

int ifindex

裝置索引

netdevice_tracker *tracker

獲取的引用的跟蹤物件

gfp_t gfp

跟蹤器的分配標誌

按索引搜尋介面。如果未找到裝置，則返回 NULL 或指向該裝置的指標。返回的裝置已新增引用，並且指標是安全的，直到使用者呼叫 netdev_put() 以指示他們已完成使用。

struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type, const char *ha)¶: 按硬體地址查詢裝置

引數

struct net *net

適用的網路名稱空間

unsigned short type

裝置媒體型別

const char *ha

硬體地址

按 MAC 地址搜尋介面。如果未找到裝置，則返回 NULL 或指向該裝置的指標。呼叫者必須持有 RCU。返回的裝置尚未增加其引用計數，因此呼叫者必須小心鎖定

struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, const char *ha)¶: 按硬體地址查詢裝置

引數

struct net *net: 適用的網路名稱空間
unsigned short type: 裝置媒體型別
const char *ha: 硬體地址

描述

類似於 dev_getbyhwaddr_rcu()，但所有者需要持有 rtnl_lock。

上下文

必須持有 rtnl_lock()。

返回 skb dst_entry

指向 net_device 的指標，如果未找到，則為 NULL

struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)¶: 查詢具有給定標誌的任何裝置

引數

struct net *net

適用的網路名稱空間

unsigned short if_flags

IFF_* 值

unsigned short mask

要檢查的 if_flags 中位的位掩碼

搜尋具有給定標誌的任何介面。如果未找到裝置，則返回 NULL 或指向該裝置的指標。必須在 rtnl_lock() 內呼叫，並且結果 refcount 不變。

bool dev_valid_name(const char *name)¶: 檢查名稱是否適合網路裝置

引數

const char *name

名稱字串

網路裝置名稱需要是有效的檔名，以允許 sysfs 工作。我們也不允許任何型別的空格。

int dev_alloc_name(struct net_device *dev, const char *name)¶: 為裝置分配名稱

引數

struct net_device *dev

裝置

const char *name

名稱格式字串

傳遞一個格式字串 - 例如“lt``d``”，它將嘗試找到合適的 ID。它掃描裝置列表以構建一個空閒地圖，然後選擇第一個空槽。呼叫者必須在分配名稱和新增裝置時持有 dev_base 或 rtnl 鎖，以避免重複。限制為 bits_per_byte * 頁面大小裝置（即大多數平臺上為 32K）。返回分配的單元編號或負 errno 程式碼。

void netdev_features_change(struct net_device *dev)¶: 裝置更改功能

引數

struct net_device *dev

導致通知的裝置

呼叫以指示裝置已更改功能。

void __netdev_notify_peers(struct net_device *dev)¶: 通知網路對等方 dev 的存在，在已經持有 rtnl 鎖時呼叫。

引數

struct net_device *dev: 網路裝置

描述

生成流量，以便感興趣的網路對等方瞭解 dev，例如透過生成無償 ARP。這可以在裝置想要通知網路的其餘部分有關某種重新配置（例如故障轉移事件或虛擬機器遷移）時使用。

void netdev_notify_peers(struct net_device *dev)¶: 通知網路對等方 dev 的存在

引數

struct net_device *dev: 網路裝置

描述

生成流量，以便感興趣的網路對等方瞭解 dev，例如透過生成無償 ARP。這可以在裝置想要通知網路的其餘部分有關某種重新配置（例如故障轉移事件或虛擬機器遷移）時使用。

int register_netdevice_notifier(struct notifier_block *nb)¶: 註冊網路通知程式塊

引數

struct notifier_block *nb: 通知程式

描述

註冊一個通知程式，以便在發生網路裝置事件時呼叫。傳遞的通知程式已連結到核心結構中，並且在登出之前不得重用。失敗時返回負 errno 程式碼。

註冊後，所有註冊和啟動事件都會重播到新的通知程式，以允許裝置以無競爭的方式檢視網路裝置列表。

int unregister_netdevice_notifier(struct notifier_block *nb)¶: 登出網路通知程式塊

引數

struct notifier_block *nb: 通知程式

描述

登出先前由 register_netdevice_notifier() 註冊的通知程式。通知程式已從核心結構中取消連結，然後可以重用。失敗時返回負 errno 程式碼。

登出後，將為裝置列表中的所有裝置合成登出和關閉裝置事件到刪除的通知程式，以消除對特殊情況清理程式碼的需求。

int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb)¶: 註冊每個 netns 網路通知程式塊

引數

struct net *net: 網路名稱空間
struct notifier_block *nb: 通知程式

描述

註冊一個通知程式，以便在發生網路裝置事件時呼叫。傳遞的通知程式已連結到核心結構中，並且在登出之前不得重用。失敗時返回負 errno 程式碼。

註冊後，所有註冊和啟動事件都會重播到新的通知程式，以允許裝置以無競爭的方式檢視網路裝置列表。

int unregister_netdevice_notifier_net(struct net *net, struct notifier_block *nb)¶: 登出每個 netns 網路通知程式塊

引數

struct net *net: 網路名稱空間
struct notifier_block *nb: 通知程式

描述

登出先前由 register_netdevice_notifier_net() 註冊的通知程式。通知程式已從核心結構中取消連結，然後可以重用。失敗時返回負 errno 程式碼。

登出後，將為裝置列表中的所有裝置合成登出和關閉裝置事件到刪除的通知程式，以消除對特殊情況清理程式碼的需求。

int call_netdevice_notifiers(unsigned long val, struct net_device *dev)¶: 呼叫所有網路通知程式塊

引數

unsigned long val

未經修改地傳遞給通知程式函式的值

struct net_device *dev

未經修改地傳遞給通知程式函式的 net_device 指標

呼叫所有網路通知程式塊。引數和返回值與 raw_notifier_call_chain() 相同。

int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)¶: 將 skb 環回到另一個 netif

引數

struct net_device *dev: 目標網路裝置
設定 skb dst: 要轉發的緩衝區

描述

返回值: NET_RX_SUCCESS（無擁塞）NET_RX_DROP（資料包已丟棄，但已釋放）

dev_forward_skb 可用於將 skb 從一個裝置的 start_xmit 函式注入到另一個裝置的接收佇列中。

接收裝置可能位於另一個名稱空間中，因此我們必須清除 skb 中可能影響名稱空間隔離的所有資訊。

bool dev_nit_active_rcu(const struct net_device *dev)¶: 如果正在使用任何網路介面 taps，則返回 true

引數

const struct net_device *dev: 要檢查是否存在 taps 的網路裝置

描述

呼叫者必須持有 RCU 鎖

int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq)¶: 設定使用的實際 RX 佇列數

引數

struct net_device *dev

網路裝置

unsigned int rxq

實際 RX 佇列數

必須在持有 rtnl_lock 或在註冊網路裝置之前呼叫此函式。成功時返回 0，或返回負錯誤程式碼。如果在註冊之前呼叫，則始終成功。

int netif_set_real_num_queues(struct net_device *dev, unsigned int txq, unsigned int rxq)¶: 設定使用的 RX 和 TX 佇列的實際數量

引數

struct net_device *dev

網路裝置

unsigned int txq

實際 TX 佇列數

unsigned int rxq

實際 RX 佇列數

設定 TX 和 RX 佇列的實際數量。如果佇列數量已正確，則不執行任何操作。

void netif_set_tso_max_size(struct net_device *dev, unsigned int size)¶: 設定支援的 TSO 幀的最大大小

引數

struct net_device *dev: 要更新的 netdev
unsigned int size: TSO 幀的最大 skb->len

描述

設定裝置可以處理的 TSO 超級幀的大小限制。除非顯式設定，否則堆疊將假定值為 GSO_LEGACY_MAX_SIZE。

void netif_set_tso_max_segs(struct net_device *dev, unsigned int segs)¶: 設定 TSO 支援的最大 segs 數

引數

struct net_device *dev: 要更新的 netdev
unsigned int segs: TCP 段的最大數量

描述

設定裝置可以從單個 TSO 超級幀生成的 TCP 段數量的限制。除非顯式設定，否則堆疊將假定值為 GSO_MAX_SEGS。

void netif_inherit_tso_max(struct net_device *to, const struct net_device *from)¶: 將所有 TSO 限制從較低裝置複製到較高裝置

引數

struct net_device *to: 要更新的 netdev
const struct net_device *from: 從中複製限制的 netdev

int netif_get_num_default_rss_queues(void)¶: RSS 佇列的預設數量

引數

void: 無引數

描述

預設值是物理核心的數量（如果只有 1 或 2 個），或者如果有更多核心，則除以 2。

void netif_device_detach(struct net_device *dev)¶: 將裝置標記為已移除

引數

struct net_device *dev: 網路裝置

描述

將裝置標記為已從系統中移除，因此不再可用。

void netif_device_attach(struct net_device *dev)¶: 將裝置標記為已連線

引數

struct net_device *dev: 網路裝置

描述

將裝置標記為已從系統連線，並在需要時重新啟動。

int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *skb)¶: 環回 skb

引數

struct net *net: 此環回發生的網路名稱空間
struct sock *sk: sk 需要是 netfilter okfn
設定 skb dst: 要傳輸的緩衝區

int __dev_queue_xmit(struct sk_buff *skb, struct net_device *sb_dev)¶: 傳輸緩衝區

引數

設定 skb dst: 要傳輸的緩衝區
struct net_device *sb_dev: 用於 L2 轉發解除安裝的子裝置

描述

將緩衝區排隊以傳輸到網路裝置。呼叫者必須在呼叫此函式之前設定裝置和優先順序並構建緩衝區。該函式可以從中斷中呼叫。

呼叫此方法時，必須啟用中斷。這是因為 BH 啟用程式碼必須啟用 IRQ，這樣它才不會死鎖。

無論返回值如何，skb 都會被消耗，因此目前很難重試向此方法的傳送。（如果小心，您可以在傳送之前增加引用計數以保留重試的引用。）

返回 skb dst_entry

0 - 緩衝區成功傳輸
正 qdisc 返回程式碼 - NET_XMIT_DROP 等。
負 errno - 其他錯誤

bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id, u16 filter_id)¶: 檢查是否可以刪除 RFS 硬體過濾器

引數

struct net_device *dev: 設定過濾器的裝置
u16 rxq_index: RX 佇列索引
u32 flow_id: 傳遞給 ndo_rx_flow_steer() 的 Flow ID
u16 filter_id: ndo_rx_flow_steer() 返回的過濾器 ID

描述

實現 ndo_rx_flow_steer() 的驅動程式應定期為每個已安裝的過濾器呼叫此函式，並刪除返回 true 的過濾器。

int __netif_rx(struct sk_buff *skb)¶: netif_rx 的略微最佳化版本

引數

設定 skb dst

要釋出的緩衝區

此行為與 netif_rx 相同，只是它不停用下半部。因此，只能從中斷上下文（硬中斷或軟中斷）呼叫此函式。

int netif_rx(struct sk_buff *skb)¶: 將緩衝區釋出到網路程式碼

引數

設定 skb dst

要釋出的緩衝區

此函式從裝置驅動程式接收資料包，並將其排隊以供上層（協議）級別透過 backlog NAPI 裝置進行處理。它總是成功。在擁塞控制期間或由協議層可能會丟棄緩衝區。網路緩衝區透過 backlog NAPI 裝置傳遞。現代 NIC 驅動程式應使用 NAPI 和 GRO。此函式可以從中斷和程序上下文中呼叫。來自程序上下文的呼叫者在呼叫此函式之前不得停用中斷。

返回值：NET_RX_SUCCESS（無擁塞）NET_RX_DROP（資料包已丟棄）

bool netdev_is_rx_handler_busy(struct net_device *dev)¶: 檢查是否已註冊接收處理程式

引數

struct net_device *dev

要檢查的裝置

檢查是否已為給定設備註冊接收處理程式。如果有一個，則返回 true。

呼叫者必須持有 rtnl_mutex。

int netdev_rx_handler_register(struct net_device *dev, rx_handler_func_t *rx_handler, void *rx_handler_data)¶: 註冊接收處理程式

引數

struct net_device *dev

要為其註冊處理程式的裝置

rx_handler_func_t *rx_handler

要註冊的接收處理程式

void *rx_handler_data

rx 處理程式使用的資料指標

為設備註冊接收處理程式。然後將從 __netif_receive_skb 呼叫此處理程式。如果失敗，則返回負 errno 程式碼。

呼叫者必須持有 rtnl_mutex。

有關 rx_handler 的一般說明，請參見 enum rx_handler_result。

void netdev_rx_handler_unregister(struct net_device *dev)¶: 登出接收處理程式

引數

struct net_device *dev

要從中登出處理程式的裝置

從設備註銷接收處理程式。

呼叫者必須持有 rtnl_mutex。

int netif_receive_skb_core(struct sk_buff *skb)¶: netif_receive_skb 的特殊用途版本

引數

設定 skb dst

要處理的緩衝區

netif_receive_skb() 的更直接接收版本。它只應由需要跳過 RPS 和通用 XDP 的呼叫者使用。呼叫者還必須注意處理 (page_is_)pfmemalloc。

此函式只能從 softirq 上下文中呼叫，並且應啟用中斷。

返回值（通常忽略）：NET_RX_SUCCESS：無擁塞 NET_RX_DROP：資料包已丟棄

int netif_receive_skb(struct sk_buff *skb)¶: 處理來自網路的接收緩衝區

引數

設定 skb dst

要處理的緩衝區

netif_receive_skb() 是主要的資料接收處理函式。它總是成功。在擁塞控制期間或由協議層可能會丟棄緩衝區。

此函式只能從 softirq 上下文中呼叫，並且應啟用中斷。

返回值（通常忽略）：NET_RX_SUCCESS：無擁塞 NET_RX_DROP：資料包已丟棄

void netif_receive_skb_list(struct list_head *head)¶: 處理來自網路的許多接收緩衝區

引數

struct list_head *head

要處理的 skb 列表。

由於通常忽略 netif_receive_skb() 的返回值，並且對於列表沒有意義，因此此函式返回 void。

此函式只能從 softirq 上下文中呼叫，並且應啟用中斷。

void __napi_schedule(struct napi_struct *n)¶: 計劃接收

引數

struct napi_struct *n: 要計劃的條目

描述

該條目的接收函式將被計劃執行。如果硬 irq 被遮蔽，請考慮使用 __napi_schedule_irqoff()。

bool napi_schedule_prep(struct napi_struct *n)¶: 檢查是否可以計劃 napi

引數

struct napi_struct *n: napi 上下文

描述

測試 NAPI 例程是否已經在執行，如果不是，則將其標記為正在執行。這用作條件變數，以確保只有一個 NAPI 輪詢例項執行。我們還確保沒有待處理的 NAPI 停用。

void __napi_schedule_irqoff(struct napi_struct *n)¶: 計劃接收

引數

struct napi_struct *n: 要計劃的條目

描述

__napi_schedule() 的變體，假設硬 irq 被遮蔽。

在啟用 PREEMPT_RT 的核心上，這會對映到 __napi_schedule()，因為由於強制執行緒中斷和自旋鎖替換，中斷停用假設可能不正確。

void netif_queue_set_napi(struct net_device *dev, unsigned int queue_index, enum netdev_queue_type type, struct napi_struct *napi)¶: 將佇列與 napi 關聯

引數

struct net_device *dev: NAPI 和佇列所屬的裝置
unsigned int queue_index: 佇列的索引
enum netdev_queue_type type: 佇列型別為 RX 或 TX
struct napi_struct *napi: NAPI 上下文，傳遞 NULL 以清除先前設定的 NAPI

描述

設定具有其相應 napi 上下文的佇列。這應在為佇列向量註冊 NAPI 處理程式以及佇列已對映到相應的中斷向量之後完成。

void napi_disable(struct napi_struct *n)¶: 阻止 NAPI 計劃

引數

struct napi_struct *n: NAPI 上下文

描述

停止在此上下文中計劃 NAPI。等待任何未完成的處理完成。為關聯的 net_device 獲取 netdev_lock()。

void napi_enable(struct napi_struct *n)¶: 啟用 NAPI 計劃

引數

struct napi_struct *n: NAPI 上下文

描述

啟用 NAPI 例項的計劃。必須與 napi_disable() 配對。為關聯的 net_device 獲取 netdev_lock()。

bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev)¶: 檢查裝置是否連結到上層裝置

引數

struct net_device *dev: 裝置
struct net_device *upper_dev: 要檢查的上層裝置

描述

查明裝置是否連結到指定的上層裝置，如果是，則返回 true。請注意，這僅檢查直接上層裝置，而不是透過完整的裝置堆疊。呼叫者必須持有 RTNL 鎖。

bool netdev_has_upper_dev_all_rcu(struct net_device *dev, struct net_device *upper_dev)¶: 檢查裝置是否連結到上層裝置

引數

struct net_device *dev: 裝置
struct net_device *upper_dev: 要檢查的上層裝置

描述

查明裝置是否連結到指定的上層裝置，如果是，則返回 true。請注意，這會檢查整個上層裝置鏈。呼叫者必須持有 rcu 鎖。

bool netdev_has_any_upper_dev(struct net_device *dev)¶: 檢查裝置是否連結到某個裝置

引數

struct net_device *dev: 裝置

描述

查明裝置是否連結到上層裝置，如果是，則返回 true。呼叫者必須持有 RTNL 鎖。

struct net_device *netdev_master_upper_dev_get(struct net_device *dev)¶: 獲取主上層裝置

引數

struct net_device *dev: 裝置

描述

查詢主上層裝置並返回指向它的指標，如果不存在，則返回 NULL。呼叫者必須持有 RTNL 鎖。

struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev, struct list_head **iter)¶: 從上層列表中獲取下一個 dev

引數

struct net_device *dev: 裝置
struct list_head **iter: 當前位置的 list_head **

描述

從 iter 位置開始，從 dev 的上層列表中獲取下一個裝置。呼叫者必須持有 RCU 讀取鎖。

void *netdev_lower_get_next_private(struct net_device *dev, struct list_head **iter)¶: 從較低鄰居列表中獲取下一個 ->private

引數

struct net_device *dev: 裝置
struct list_head **iter: 當前位置的 list_head **

描述

從 iter 位置開始，從 dev 的較低鄰居列表中獲取下一個 netdev_adjacent->private。呼叫者必須持有 RTNL 鎖，或者其自己的鎖定，以保證鄰居較低列表將保持不變。

void *netdev_lower_get_next_private_rcu(struct net_device *dev, struct list_head **iter)¶: 從較低鄰居列表中獲取下一個 ->private，RCU 變體

引數

struct net_device *dev: 裝置
struct list_head **iter: 當前位置的 list_head **

描述

從 iter 位置開始，從 dev 的較低鄰居列表中獲取下一個 netdev_adjacent->private。呼叫者必須持有 RCU 讀取鎖。

void *netdev_lower_get_next(struct net_device *dev, struct list_head **iter)¶: 從較低鄰居列表中獲取下一個裝置

引數

struct net_device *dev: 裝置
struct list_head **iter: 當前位置的 list_head **

描述

從 iter 位置開始，從 dev 的較低鄰居列表中獲取下一個 netdev_adjacent。呼叫者必須持有 RTNL 鎖，或者其自己的鎖定，以保證鄰居較低列表將保持不變。

void *netdev_lower_get_first_private_rcu(struct net_device *dev)¶: 從較低鄰居列表中獲取第一個 ->private，RCU 變體

引數

struct net_device *dev: 裝置

描述

從 dev 的較低鄰居列表中獲取第一個 netdev_adjacent->private。呼叫者必須持有 RCU 讀取鎖。

struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev)¶: 獲取主上層裝置

引數

struct net_device *dev: 裝置

描述

查詢主上層裝置並返回指向它的指標，如果不存在，則返回 NULL。呼叫者必須持有 RCU 讀取鎖。

int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev, struct netlink_ext_ack *extack)¶: 新增指向上層裝置的連結

引數

struct net_device *dev: 裝置
struct net_device *upper_dev: 新的上層裝置
struct netlink_ext_ack *extack: netlink 擴充套件 ack

描述

新增指向此裝置的上層裝置的連結。呼叫者必須持有 RTNL 鎖。如果失敗，則返回負 errno 程式碼。成功後，引用計數將調整，該函式將返回零。

int netdev_master_upper_dev_link(struct net_device *dev, struct net_device *upper_dev, void *upper_priv, void *upper_info, struct netlink_ext_ack *extack)¶: 新增指向上層裝置的主連結

引數

struct net_device *dev: 裝置
struct net_device *upper_dev: 新的上層裝置
void *upper_priv: 上層裝置 private
void *upper_info: 要透過通知程式傳遞的上層資訊
struct netlink_ext_ack *extack: netlink 擴充套件 ack

描述

新增一個連結到此裝置之上的裝置。在這種情況下，只能連結一個主上層裝置，儘管其他非主裝置也可能被連結。呼叫者必須持有 RTNL 鎖。失敗時返回一個負的 errno 程式碼。成功時，引用計數會被調整，函式返回零。

void netdev_upper_dev_unlink(struct net_device *dev, struct net_device *upper_dev)¶: 移除一個到上層裝置的連結

引數

struct net_device *dev: 裝置
struct net_device *upper_dev: 新的上層裝置

描述

移除一個到此裝置之上的裝置的連結。呼叫者必須持有 RTNL 鎖。

void netdev_bonding_info_change(struct net_device *dev, struct netdev_bonding_info *bonding_info)¶: 分發關於從裝置變更的事件

引數

struct net_device *dev: 裝置
struct netdev_bonding_info *bonding_info: 要分發的資訊

描述

使用 info 傳送 NETDEV_BONDING_INFO 到 netdev 通知器。呼叫者必須持有 RTNL 鎖。

struct net_device *netdev_get_xmit_slave(struct net_device *dev, struct sk_buff *skb, bool all_slaves)¶: 獲取主裝置的 xmit 從裝置

引數

struct net_device *dev: 裝置
設定 skb dst: 資料包
bool all_slaves: 假設所有的從裝置都是活動的

描述

引用計數器不會遞增，因此呼叫者必須小心鎖。呼叫者必須持有 RCU 鎖。如果沒有找到從裝置，則返回 NULL。

struct net_device *netdev_sk_get_lowest_dev(struct net_device *dev, struct sock *sk)¶: 獲取給定裝置和套接字鏈中的最低裝置

引數

struct net_device *dev: 裝置
struct sock *sk: 套接字

描述

如果沒有找到更低的裝置，則返回 NULL。

void netdev_lower_state_changed(struct net_device *lower_dev, void *lower_state_info)¶: 分發關於底層裝置狀態變更的事件

引數

struct net_device *lower_dev: 裝置
void *lower_state_info: 要分發的狀態

描述

使用 info 傳送 NETDEV_CHANGELOWERSTATE 到 netdev 通知器。呼叫者必須持有 RTNL 鎖。

unsigned int dev_get_flags(const struct net_device *dev)¶: 獲取報告給使用者空間的標誌

引數

const struct net_device *dev

裝置

獲取透過 API 匯出到使用者空間的標誌位的組合。

int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr, struct netlink_ext_ack *extack)¶: 呼叫 NETDEV_PRE_CHANGEADDR。

引數

struct net_device *dev: 裝置
const char *addr: 新地址
struct netlink_ext_ack *extack: netlink 擴充套件 ack

int dev_get_port_parent_id(struct net_device *dev, struct netdev_phys_item_id *ppid, bool recurse)¶: 獲取裝置的埠父識別符號

引數

struct net_device *dev

網路裝置

struct netdev_phys_item_id *ppid

指向埠父識別符號儲存區的指標

bool recurse

允許/不允許遞迴到下層裝置

獲取裝置的埠父識別符號

bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b)¶: 指示兩個網路裝置是否具有相同的埠父識別符號

引數

struct net_device *a: 第一個網路裝置
struct net_device *b: 第二個網路裝置

void netdev_update_features(struct net_device *dev)¶: 重新計算裝置特性

引數

struct net_device *dev

要檢查的裝置

重新計算 dev->features 集合，並在其已更改時傳送通知。應該在驅動程式或硬體相關條件可能已更改（影響特性）後呼叫。

void netdev_change_features(struct net_device *dev)¶: 重新計算裝置特性

引數

struct net_device *dev

要檢查的裝置

重新計算 dev->features 集合，即使它們沒有更改也傳送通知。如果 dev->vlan_features 也可能已更改，則應呼叫此函式而不是 netdev_update_features()，以允許將更改傳播到堆疊的 VLAN 裝置。

void netif_stacked_transfer_operstate(const struct net_device *rootdev, struct net_device *dev)¶: 傳輸 operstate

引數

const struct net_device *rootdev

要從中傳輸狀態的根或下層裝置

struct net_device *dev

要將 operstate 傳輸到的裝置

將 operational 狀態從 root 傳輸到 device。這通常在根裝置和裝置（葉裝置）之間存在堆疊關係時呼叫。

int register_netdevice(struct net_device *dev)¶: 註冊一個網路裝置

引數

struct net_device *dev: 要註冊的裝置

描述

獲取一個已準備好的網路裝置結構，並使其可以從外部訪問。將一個 NETDEV_REGISTER 訊息傳送到 netdev 通知器鏈。呼叫者必須持有 rtnl 鎖 - 您可能需要 register_netdev() 而不是這個。

int register_netdev(struct net_device *dev)¶: 註冊一個網路裝置

引數

struct net_device *dev

要註冊的裝置

獲取一個已完成的網路裝置結構，並將其新增到核心介面。將一個 NETDEV_REGISTER 訊息傳送到 netdev 通知器鏈。成功時返回 0。如果裝置設定失敗，或者名稱重複，則返回一個負的 errno 程式碼。

這是 register_netdevice 的一個包裝器，它獲取 rtnl 訊號量，並擴充套件裝置名稱（如果您將格式字串傳遞給 alloc_netdev）。

struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev, struct rtnl_link_stats64 *storage)¶: 獲取網路裝置統計資訊

引數

struct net_device *dev

從中獲取統計資訊的裝置

struct rtnl_link_stats64 *storage

儲存統計資訊的位置

從裝置獲取網路統計資訊。返回 storage。裝置驅動程式可以透過設定 dev->netdev_ops->get_stats64 或 dev->netdev_ops->get_stats 來提供自己的方法；否則，將使用內部統計資訊結構。

void dev_fetch_sw_netstats(struct rtnl_link_stats64 *s, const struct pcpu_sw_netstats __percpu *netstats)¶: 獲取每個 CPU 的網路裝置統計資訊

引數

struct rtnl_link_stats64 *s

儲存統計資訊的位置

const struct pcpu_sw_netstats __percpu *netstats

要從中讀取的每個 CPU 的網路統計資訊

讀取每個 CPU 的網路統計資訊，並填充 s 中的相關欄位。

void dev_get_tstats64(struct net_device *dev, struct rtnl_link_stats64 *s)¶: ndo_get_stats64 實現

引數

struct net_device *dev

從中獲取統計資訊的裝置

struct rtnl_link_stats64 *s

儲存統計資訊的位置

從 dev->stats 和 dev->tstats 填充 s。可以用作 ndo_get_stats64() 回撥。

void netdev_sw_irq_coalesce_default_on(struct net_device *dev)¶: 預設啟用 SW IRQ 合併

引數

struct net_device *dev: 要在其上啟用 IRQ 合併的 netdev

描述

為 SW IRQ 合併設定一個保守的預設值。使用者可以使用 sysfs 屬性來覆蓋預設值。

struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name, unsigned char name_assign_type, void (*setup)(struct net_device*), unsigned int txqs, unsigned int rxqs)¶: 分配網路裝置

引數

int sizeof_priv: 要為其分配空間的的私有資料的大小
const char *name: 裝置名稱格式字串
unsigned char name_assign_type: 裝置名稱的來源
void (*setup)(struct net_device *): 初始化裝置的回撥
unsigned int txqs: 要分配的 TX 子佇列的數量
unsigned int rxqs: 要分配的 RX 子佇列的數量

描述

分配一個 struct net_device，其中包含供驅動程式使用的私有資料區域，並執行基本初始化。還為裝置上的每個佇列分配子佇列結構。

void free_netdev(struct net_device *dev)¶: 釋放網路裝置

引數

struct net_device *dev: 裝置

描述

此函式執行銷燬已分配的裝置介面的最後階段。釋放對裝置物件的引用。如果這是最後一個引用，那麼它將被釋放。必須在程序上下文中呼叫。

struct net_device *alloc_netdev_dummy(int sizeof_priv)¶: 分配並初始化一個虛擬網路裝置。

引數

int sizeof_priv: 要為其分配空間的的私有資料的大小

返回 skb dst_entry

成功時分配的 net_device，否則為 NULL

void synchronize_net(void)¶: 與資料包接收處理同步

引數

void: 無引數

描述

等待當前正在接收的資料包完成。不會阻止稍後的資料包啟動。

void unregister_netdevice_queue(struct net_device *dev, struct list_head *head)¶: 從核心中移除裝置

引數

struct net_device *dev

裝置

struct list_head *head

list

此函式關閉一個裝置介面，並將其從核心表中移除。如果 head 不為 NULL，則裝置將被排隊，以便稍後取消註冊。

呼叫者必須持有 rtnl 訊號量。您可能需要 unregister_netdev() 而不是這個。

void unregister_netdevice_many(struct list_head *head)¶: 取消註冊多個裝置

引數

struct list_head *head: 裝置列表

注意

由於大多數呼叫者使用堆疊分配的 list_head，: 我們強制執行一個 list_del()，以確保堆疊稍後不會被損壞。

void unregister_netdev(struct net_device *dev)¶: 從核心中移除裝置

引數

struct net_device *dev

裝置

此函式關閉一個裝置介面，並將其從核心表中移除。

這只是 unregister_netdevice 的一個包裝器，它獲取 rtnl 訊號量。通常您希望使用此函式，而不是 unregister_netdevice。

netdev_features_t netdev_increment_features(netdev_features_t all, netdev_features_t one, netdev_features_t mask)¶: 將特性集合遞增 1

引數

netdev_features_t all

當前的特性集合

netdev_features_t one

新的特性集合

netdev_features_t mask

掩碼特性集合

在將具有特性集合 one 的裝置新增到具有當前特性集合 all 的主裝置之後，計算出一個新的特性集合。不會啟用 mask 中關閉的任何內容。返回新的特性集合。

int eth_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, const void *daddr, const void *saddr, unsigned int len)¶: 建立乙太網頭部

引數

設定 skb dst: 要更改的緩衝區
struct net_device *dev: 源裝置
unsigned short type: 乙太網型別欄位
const void *daddr: 目標地址（NULL 表示保留目標地址）
const void *saddr: 源地址（NULL 表示使用裝置源地址）
unsigned int len: 資料包長度（<= skb->len）

描述

設定協議型別。對於 ETH_P_802_3/2 型別的資料包，我們在這裡放入長度。

u32 eth_get_headlen(const struct net_device *dev, const void *data, u32 len)¶: 確定乙太網幀的頭部長度

引數

const struct net_device *dev: 指向網路裝置的指標
const void *data: 指向幀起點的指標
u32 len: 幀的總長度

描述

盡最大努力拉取線性緩衝區中給定幀的所有頭部的長度。

__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev)¶: 確定資料包的協議 ID。

引數

設定 skb dst: 接收到的套接字資料
struct net_device *dev: 接收網路裝置

描述

這裡的規則是，如果型別欄位足夠短，可以作為長度，那麼我們就假設是 802.3。這是一種正常的做法，適用於任何“現在使用的”協議。

int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr)¶: 從資料包中提取硬體地址

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 要從中提取頭部的資料包
unsigned char *haddr: 目標緩衝區

int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type)¶: 從鄰居填充快取條目

引數

const struct neighbour *neigh: 源鄰居
struct hh_cache *hh: 目標快取條目
__be16 type: 乙太網型別欄位

描述

從鄰居建立一個乙太網頭部模板。

void eth_header_cache_update(struct hh_cache *hh, const struct net_device *dev, const unsigned char *haddr)¶: 更新快取條目

引數

struct hh_cache *hh: 目標快取條目
const struct net_device *dev: 網路裝置
const unsigned char *haddr: 新的硬體地址

描述

由地址解析模組呼叫，以通知地址的更改。

__be16 eth_header_parse_protocol(const struct sk_buff *skb)¶: 從 L2 頭部提取協議

引數

測試 skb 是否從 PFMEMALLOC 保留區分配: 從中提取協議的資料包

int eth_prepare_mac_addr_change(struct net_device *dev, void *p)¶: 準備 MAC 地址更改

引數

struct net_device *dev: 網路裝置
void *p: 套接字地址

void eth_commit_mac_addr_change(struct net_device *dev, void *p)¶: 提交 MAC 地址更改

引數

struct net_device *dev: 網路裝置
void *p: 套接字地址

int eth_mac_addr(struct net_device *dev, void *p)¶: 設定新的乙太網硬體地址

引數

struct net_device *dev: 網路裝置
void *p: 套接字地址

描述

更改裝置的硬體地址。

這不會更改硬體匹配，因此需要為大多數真實裝置重寫。

void ether_setup(struct net_device *dev)¶: 設定乙太網網路裝置

引數

struct net_device *dev: 網路裝置

描述

用乙太網通用值填充裝置結構的欄位。

struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs, unsigned int rxqs)¶: 分配和設定乙太網裝置

引數

int sizeof_priv: 要為此乙太網裝置分配的額外驅動程式私有結構的大小
unsigned int txqs: 此裝置具有的 TX 佇列數。
unsigned int rxqs: 此裝置具有的 RX 佇列數。

描述

用乙太網通用值填充裝置結構的欄位。基本上完成了除註冊裝置外的所有操作。

構造一個新的網路裝置，並具有大小為 (sizeof_priv) 的私有資料區域。此私有資料區域強制執行 32 位元組（非位）對齊。

int platform_get_ethdev_address(struct device *dev, struct net_device *netdev)¶: 從給定裝置設定 netdev 的 MAC 地址

引數

struct device *dev: 指向裝置的指標
struct net_device *netdev: 指向要寫入地址的 netdev 的指標

描述

eth_platform_get_mac_address() 的包裝器，它將地址直接寫入 netdev->dev_addr。

int fwnode_get_mac_address(struct fwnode_handle *fwnode, char *addr)¶: 從韌體節點獲取 MAC

引數

struct fwnode_handle *fwnode: 指向韌體節點的指標
char *addr: 用於儲存 MAC 的緩衝區地址

描述

在韌體節點中搜索要使用的最佳 MAC 地址。首先檢查“mac-address”，因為這應該包含“最新”MAC 地址。如果未設定，則接下來檢查“local-mac-address”，因為這是預設地址。如果未設定，則檢查過時的“address”，以防我們使用舊的裝置樹。

請注意，“address”屬性應包含暫存器集的虛擬地址，但某些 DTS 檔案已將該屬性重新定義為 MAC 地址。

拒絕全零 MAC 地址，因為這些可能是韌體表中存在的屬性，但未由韌體更新。例如，DTS 可以定義“mac-address”和“local-mac-address”，並具有零 MAC 地址。一些較舊的 U-Boot 僅初始化“local-mac-address”。在這種情況下，真正的 MAC 在“local-mac-address”中，“mac-address”存在但全部為零。

int device_get_mac_address(struct device *dev, char *addr)¶: 獲取給定裝置的 MAC

引數

struct device *dev: 指向裝置的指標
char *addr: 用於儲存 MAC 的緩衝區地址

int device_get_ethdev_address(struct device *dev, struct net_device *netdev)¶: 從給定裝置設定 netdev 的 MAC 地址

引數

struct device *dev: 指向裝置的指標
struct net_device *netdev: 指向要寫入地址的 netdev 的指標

描述

device_get_mac_address() 的包裝器，它將地址直接寫入 netdev->dev_addr。

void netif_carrier_on(struct net_device *dev)¶: 設定載波

引數

struct net_device *dev: 網路裝置

描述

裝置已檢測到獲取載波。

void netif_carrier_off(struct net_device *dev)¶: 清除載波

引數

struct net_device *dev: 網路裝置

描述

裝置已檢測到載波丟失。

void netif_carrier_event(struct net_device *dev)¶: 報告載波狀態事件

引數

struct net_device *dev: 網路裝置

描述

裝置已檢測到載波事件，但載波狀態未更改。在以非同步方式查詢載波狀態時，在驅動程式中使用，以避免在連結恢復之前查詢到連結恢復的情況下錯過事件（連結抖動）。

bool is_link_local_ether_addr(const u8 *addr)¶: 確定給定的乙太網地址是否為鏈路本地地址

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址是鏈路本地保留地址 (01:80:c2:00:00:0X)，則為 true，按照 IEEE 802.1Q 8.6.3 幀過濾。

描述

請注意：addr 必須與 u16 對齊。

bool is_zero_ether_addr(const u8 *addr)¶: 確定給定的乙太網地址是否全為零。

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址全為零，則為 true。

描述

請注意：addr 必須與 u16 對齊。

bool is_multicast_ether_addr(const u8 *addr)¶: 確定乙太網地址是否為多播地址。

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址是多播地址，則為 true。根據定義，廣播地址也是多播地址。

bool is_local_ether_addr(const u8 *addr)¶: 確定乙太網地址是否為本地分配的地址 (IEEE 802)。

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址是本地地址，則為 true。

bool is_broadcast_ether_addr(const u8 *addr)¶: 確定乙太網地址是否為廣播地址

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址是廣播地址，則為 true。

描述

請注意：addr 必須與 u16 對齊。

bool is_unicast_ether_addr(const u8 *addr)¶: 確定乙太網地址是否為單播地址

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

如果地址是單播地址，則為 true。

bool is_valid_ether_addr(const u8 *addr)¶: 確定給定的乙太網地址是否有效

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

描述

檢查乙太網地址 (MAC) 是否不是 00:00:00:00:00:00，不是多播地址，也不是 FF:FF:FF:FF:FF:FF。

請注意：addr 必須與 u16 對齊。

返回 skb dst_entry

如果地址有效，則為 true。

bool eth_proto_is_802_3(__be16 proto)¶: 確定給定的 Ethertype/長度是否為協議

引數

__be16 proto: 要測試的 Ethertype/長度值

描述

檢查 Ethertype/長度欄位中的值是否為有效的 Ethertype。

返回 skb dst_entry

如果有效值為 802.3 支援的 Ethertype，則為 true。

void eth_random_addr(u8 *addr)¶: 生成軟體分配的隨機乙太網地址

引數

u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

描述

生成一個不是多播並且設定了本地分配位的隨機乙太網地址 (MAC)。

void eth_broadcast_addr(u8 *addr)¶: 分配廣播地址

引數

u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

描述

將廣播地址分配給給定的地址陣列。

void eth_zero_addr(u8 *addr)¶: 分配零地址

引數

u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

描述

將零地址分配給給定的地址陣列。

void eth_hw_addr_random(struct net_device *dev)¶: 生成軟體分配的隨機乙太網地址並設定裝置標誌

引數

struct net_device *dev: 指向 net_device 結構的指標

描述

生成要由網路裝置使用的隨機乙太網地址 (MAC)，並設定 addr_assign_type，以便 sysfs 可以讀取該狀態，並且使用者空間可以使用該狀態。

u32 eth_hw_addr_crc(struct netdev_hw_addr *ha)¶: 從 netdev_hw_addr 計算 CRC

引數

struct netdev_hw_addr *ha: 指向硬體地址的指標

描述

從硬體地址計算 CRC 作為過濾器雜湊的基礎。

void ether_addr_copy(u8 *dst, const u8 *src)¶: 複製乙太網地址

引數

u8 *dst: 指向六位元組陣列乙太網地址目標的指標
const u8 *src: 指向六位元組陣列乙太網地址源的指標

描述

請注意：dst 和 src 都必須與 u16 對齊。

void eth_hw_addr_set(struct net_device *dev, const u8 *addr)¶: 將乙太網地址分配給 net_device

引數

struct net_device *dev: 指向 net_device 結構的指標
const u8 *addr: 要分配的地址

描述

將給定地址分配給 net_device，addr_assign_type 不會更改。

void eth_hw_addr_inherit(struct net_device *dst, struct net_device *src)¶: 從另一個 net_device 複製 dev_addr

引數

struct net_device *dst: 指向要複製 dev_addr 的 net_device 的指標
struct net_device *src: 指向要從中複製 dev_addr 的 net_device 的指標

描述

將乙太網地址從一個 net_device 複製到另一個 net_device 以及地址屬性 (addr_assign_type)。

bool ether_addr_equal(const u8 *addr1, const u8 *addr2)¶: 比較兩個乙太網地址

引數

const u8 *addr1: 指向包含乙太網地址的六位元組陣列的指標
const u8 *addr2: 指向包含乙太網地址的其他六位元組陣列的指標

描述

比較兩個乙太網地址，如果相等則返回 true

請注意：addr1 和 addr2 都必須與 u16 對齊。

bool ether_addr_equal_64bits(const u8 *addr1, const u8 *addr2)¶: 比較兩個乙太網地址

引數

const u8 *addr1: 指向 8 位元組陣列的指標
const u8 *addr2: 指向另一個 8 位元組陣列的指標

描述

比較兩個乙太網地址，如果相等則返回 true，否則返回 false。

該函式不需要任何條件分支，並且可能在 CPU 上使用字記憶體訪問，從而允許廉價的未對齊記憶體讀取。陣列 = { byte1, byte2, byte3, byte4, byte5, byte6, pad1, pad2 }

請注意，addr1 和 addr2 的對齊方式僅保證為 16 位。

bool ether_addr_equal_unaligned(const u8 *addr1, const u8 *addr2)¶: 比較兩個未 u16 對齊的乙太網地址

引數

const u8 *addr1: 指向包含乙太網地址的六位元組陣列的指標
const u8 *addr2: 指向包含乙太網地址的其他六位元組陣列的指標

描述

比較兩個乙太網地址，如果相等則返回 true

請注意：僅當任何乙太網地址可能未 u16 對齊時才使用。

bool ether_addr_equal_masked(const u8 *addr1, const u8 *addr2, const u8 *mask)¶: 使用掩碼比較兩個乙太網地址

引數

const u8 *addr1: 指向包含第一個乙太網地址的六位元組陣列的指標
const u8 *addr2: 指向包含第二個乙太網地址的六位元組陣列的指標
const u8 *mask: 指向包含乙太網地址位掩碼的六位元組陣列的指標

描述

使用掩碼比較兩個乙太網地址，如果對於位掩碼中設定的每個位，乙太網地址中的等效位相等，則返回 true。使用設定了所有位的掩碼是較慢的 ether_addr_equal。

u64 ether_addr_to_u64(const u8 *addr)¶: 將乙太網地址轉換為 u64 值。

引數

const u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

返回 skb dst_entry

地址的 u64 值

void u64_to_ether_addr(u64 u, u8 *addr)¶: 將 u64 轉換為乙太網地址。

引數

u64 u: 要轉換為乙太網 MAC 地址的 u64
u8 *addr: 指向包含乙太網地址的六位元組陣列的指標

void eth_addr_dec(u8 *addr)¶: 遞減給定的 MAC 地址

引數

u8 *addr: 指向包含要遞減的乙太網地址的六位元組陣列的指標

void eth_addr_inc(u8 *addr)¶: 遞增給定的 MAC 地址。

引數

u8 *addr: 指向包含要遞增的乙太網地址的六位元組陣列的指標。

void eth_addr_add(u8 *addr, long offset)¶: 將偏移量新增到給定的 MAC 地址（或從中減去）。

引數

u8 *addr: 指向包含要遞增的乙太網地址的六位元組陣列的指標。
long offset: 要新增的偏移量。

bool is_etherdev_addr(const struct net_device *dev, const u8 addr[6 + 2])¶: 判斷給定的乙太網地址是否屬於裝置。

引數

const struct net_device *dev: 指向裝置結構的指標
const u8 addr[6 + 2]: 指向包含乙太網地址的六位元組陣列的指標

描述

將傳遞的地址與裝置的所有地址進行比較。如果地址是裝置地址之一，則返回 true。

請注意，此函式呼叫 ether_addr_equal_64bits()，因此請注意正確的填充。

unsigned long compare_ether_header(const void *a, const void *b)¶: 比較兩個乙太網頭部

引數

const void *a: 指向乙太網頭部的指標
const void *b: 指向乙太網頭部的指標

描述

比較兩個乙太網頭部，如果相等則返回 0。這假設網路頭部（即 IP 頭部）是 4 位元組對齊的，或者平臺可以處理未對齊的訪問。對於進入 netif_receive_skb 或類似入口點的所有資料包都是這種情況。

void eth_hw_addr_gen(struct net_device *dev, const u8 *base_addr, unsigned int id)¶: 生成乙太網地址並將其分配給埠

引數

struct net_device *dev: 指向埠的 net_device 結構的指標
const u8 *base_addr: 基本乙太網地址
unsigned int id: 要新增到基本地址的偏移量

描述

使用基本地址和偏移量生成 MAC 地址，並將其分配給 net_device。通常由需要計算所有埠地址的交換機驅動程式使用。 addr_assign_type 不會更改。

void eth_skb_pkt_type(struct sk_buff *skb, const struct net_device *dev)¶: 如果目標地址不匹配，則分配資料包型別

引數

設定 skb dst: 如果地址與 dev 地址不匹配，則分配資料包型別
const struct net_device *dev: 用於比較資料包地址的網路裝置

描述

如果資料包的目標 MAC 地址與網路裝置地址不匹配，則分配適當的資料包型別。

int eth_skb_pad(struct sk_buff *skb)¶: 將緩衝區填充到乙太網幀的最小八位位元組數

引數

設定 skb dst: 要填充的緩衝區

描述

乙太網幀的最小大小應為 60 位元組。此函式接受短幀，並用零填充它們，直到達到 60 位元組的限制。

struct gro_node¶: 支援通用接收解除安裝的結構

定義:

struct gro_node {
    unsigned long           bitmask;
    struct gro_list         hash[GRO_HASH_BUCKETS];
    struct list_head        rx_list;
    u32 rx_count;
    u32 cached_napi_id;
};

成員

位掩碼: 位掩碼，用於指示 hash 中使用的儲存桶
我們到達的裝置的 ifindex: 待處理聚合 skb 的雜湊表，按流分隔
rx_list: 待處理的 GRO_NORMAL skb 列表
rx_count: 快取的 rx_list 當前長度
cached_napi_id: 為熱路徑快取的 napi_struct::napi_id，獨立使用時為 0

bool napi_is_scheduled(struct napi_struct *n)¶: 測試 NAPI 是否已排程

引數

struct napi_struct *n: NAPI 上下文

描述

此檢查是“盡力而為”的。由於沒有實現鎖定，NAPI 可以在此檢查後立即被排程或終止，併產生不精確的結果。

NAPI_STATE_SCHED 是一個內部狀態，通常不應使用 napi_is_scheduled，而應使用 napi_schedule。

僅當驅動程式確實需要檢查 NAPI 是否已排程時才使用，例如在延遲定時器的上下文中，如果 NAPI 已排程，則可以跳過該定時器。

返回 skb dst_entry

如果 NAPI 已排程，則為 True，否則為 False。

bool napi_schedule(struct napi_struct *n)¶: 排程 NAPI 輪詢

引數

struct napi_struct *n: NAPI 上下文

描述

如果 NAPI 輪詢例程尚未執行，則排程它以被呼叫。

返回 skb dst_entry

如果我們排程了 NAPI，則為 true，否則為 false。有關為什麼可能未排程 NAPI 的其他原因，請參閱 napi_schedule_prep()。

void napi_schedule_irqoff(struct napi_struct *n)¶: 排程 NAPI 輪詢

引數

struct napi_struct *n: NAPI 上下文

描述

napi_schedule() 的變體，假設硬中斷已被遮蔽。

bool napi_complete_done(struct napi_struct *n, int work_done)¶: NAPI 處理完成

引數

struct napi_struct *n: NAPI 上下文
int work_done: 處理的資料包數量

描述

將 NAPI 處理標記為完成。僅應在尚未完全消耗輪詢預算時呼叫。優先於 napi_complete()。

返回 skb dst_entry

如果裝置應避免重新啟用中斷，則為 false。

void napi_synchronize(const struct napi_struct *n)¶: 等待 NAPI 不再執行

引數

const struct napi_struct *n: NAPI 上下文

描述

等待 NAPI 在此上下文中完成排程。等待任何未完成的處理完成，但不停用未來的啟用。

bool napi_if_scheduled_mark_missed(struct napi_struct *n)¶: 如果 napi 正在執行，則設定 NAPIF_STATE_MISSED

引數

struct napi_struct *n: NAPI 上下文

描述

如果 napi 正在執行，則設定 NAPIF_STATE_MISSED，如果 NAPI 已排程，則返回 true。

enum netdev_priv_flags¶: struct net_device priv_flags

常量

IFF_802_1Q_VLAN: 802.1Q VLAN 裝置
IFF_EBRIDGE: 乙太網橋接裝置
IFF_BONDING: bonding 主裝置或從裝置
IFF_ISATAP: ISATAP 介面 (RFC4214)
IFF_WAN_HDLC: WAN HDLC 裝置
IFF_XMIT_DST_RELEASE: 允許 dev_hard_start_xmit() 釋放 skb->dst
IFF_DONT_BRIDGE: 不允許橋接此乙太網裝置
IFF_DISABLE_NETPOLL: 在執行時停用 netpoll
IFF_MACVLAN_PORT: 用作 macvlan 埠的裝置
IFF_BRIDGE_PORT: 用作橋埠的裝置
IFF_OVS_DATAPATH: 用作 Open vSwitch 資料路徑埠的裝置
IFF_TX_SKB_SHARING: 該介面支援在傳輸時共享 skb
IFF_UNICAST_FLT: 支援單播過濾
IFF_TEAM_PORT: 用作 team 埠的裝置
IFF_SUPP_NOFCS: 裝置支援傳送自定義 FCS
IFF_LIVE_ADDR_CHANGE: 裝置支援在執行時更改硬體地址
IFF_MACVLAN: Macvlan 裝置
IFF_XMIT_DST_RELEASE_PERM: IFF_XMIT_DST_RELEASE 不考慮底層堆疊裝置
IFF_L3MDEV_MASTER: 裝置是 L3 主裝置
IFF_NO_QUEUE: 裝置可以在沒有連線 qdisc 的情況下執行
IFF_OPENVSWITCH: 裝置是 Open vSwitch 主裝置
IFF_L3MDEV_SLAVE: 裝置是從屬於 L3 主裝置的從裝置
IFF_TEAM: 裝置是一個 team 裝置
IFF_RXFH_CONFIGURED: 裝置已配置 Rx 流重定向表
IFF_PHONY_HEADROOM: 頭空間值由外部實體控制（即橋接 veth 的主裝置）
IFF_MACSEC: 裝置是 MACsec 裝置
IFF_NO_RX_HANDLER: 裝置不支援 rx_handler 鉤子
IFF_FAILOVER: 裝置是一個故障轉移主裝置
IFF_FAILOVER_SLAVE: 裝置是故障轉移主裝置的下層裝置
IFF_L3MDEV_RX_HANDLER: 僅呼叫 L3 主裝置的 rx 處理程式
IFF_NO_ADDRCONF: 阻止 ipv6 addrconf
IFF_TX_SKB_NO_LINEAR: 裝置/驅動程式能夠傳輸 skb_headlen(skb) == 0 的幀（資料從 frag0 開始）

描述

這些是 struct net_device，它們僅由驅動程式在內部設定，並在核心中使用。這些標誌對使用者空間不可見；這意味著這些標誌的順序可以在任何核心版本中更改。

您應該在 net_device::priv_flags (熱路徑) 或 ::threaded (慢路徑) 之後新增位域布林值，而不是擴充套件這些標誌。

struct net_device¶: DEVICE 結構。

定義:

struct net_device {
    __cacheline_group_begin(net_device_read_tx);
    unsigned long           priv_flags:32;
    unsigned long           lltx:1;
    unsigned long           netmem_tx:1;
    const struct net_device_ops *netdev_ops;
    const struct header_ops *header_ops;
    struct netdev_queue     *_tx;
    netdev_features_t gso_partial_features;
    unsigned int            real_num_tx_queues;
    unsigned int            gso_max_size;
    unsigned int            gso_ipv4_max_size;
    u16 gso_max_segs;
    s16 num_tc;
    unsigned int            mtu;
    unsigned short          needed_headroom;
    struct netdev_tc_txq    tc_to_txq[TC_MAX_QUEUE];
#ifdef CONFIG_XPS;
    struct xps_dev_maps __rcu *xps_maps[XPS_MAPS_MAX];
#endif;
#ifdef CONFIG_NETFILTER_EGRESS;
    struct nf_hook_entries __rcu *nf_hooks_egress;
#endif;
#ifdef CONFIG_NET_XGRESS;
    struct bpf_mprog_entry __rcu *tcx_egress;
#endif;
    __cacheline_group_end(net_device_read_tx);
    __cacheline_group_begin(net_device_read_txrx);
    union {
        struct pcpu_lstats __percpu             *lstats;
        struct pcpu_sw_netstats __percpu        *tstats;
        struct pcpu_dstats __percpu             *dstats;
    };
    unsigned long           state;
    unsigned int            flags;
    unsigned short          hard_header_len;
    netdev_features_t features;
    struct inet6_dev __rcu  *ip6_ptr;
    __cacheline_group_end(net_device_read_txrx);
    __cacheline_group_begin(net_device_read_rx);
    struct bpf_prog __rcu   *xdp_prog;
    struct list_head        ptype_specific;
    int ifindex;
    unsigned int            real_num_rx_queues;
    struct netdev_rx_queue  *_rx;
    unsigned int            gro_max_size;
    unsigned int            gro_ipv4_max_size;
    rx_handler_func_t __rcu *rx_handler;
    void __rcu              *rx_handler_data;
    possible_net_t nd_net;
#ifdef CONFIG_NETPOLL;
    struct netpoll_info __rcu       *npinfo;
#endif;
#ifdef CONFIG_NET_XGRESS;
    struct bpf_mprog_entry __rcu *tcx_ingress;
#endif;
    __cacheline_group_end(net_device_read_rx);
    char name[IFNAMSIZ];
    struct netdev_name_node *name_node;
    struct dev_ifalias      __rcu *ifalias;
    unsigned long           mem_end;
    unsigned long           mem_start;
    unsigned long           base_addr;
    struct list_head        dev_list;
    struct list_head        napi_list;
    struct list_head        unreg_list;
    struct list_head        close_list;
    struct list_head        ptype_all;
    struct {
        struct list_head upper;
        struct list_head lower;
    } adj_list;
    xdp_features_t xdp_features;
    const struct xdp_metadata_ops *xdp_metadata_ops;
    const struct xsk_tx_metadata_ops *xsk_tx_metadata_ops;
    unsigned short          gflags;
    unsigned short          needed_tailroom;
    netdev_features_t hw_features;
    netdev_features_t wanted_features;
    netdev_features_t vlan_features;
    netdev_features_t hw_enc_features;
    netdev_features_t mpls_features;
    unsigned int            min_mtu;
    unsigned int            max_mtu;
    unsigned short          type;
    unsigned char           min_header_len;
    unsigned char           name_assign_type;
    int group;
    struct net_device_stats stats;
    struct net_device_core_stats __percpu *core_stats;
    atomic_t carrier_up_count;
    atomic_t carrier_down_count;
#ifdef CONFIG_WIRELESS_EXT;
    const struct iw_handler_def *wireless_handlers;
#endif;
    const struct ethtool_ops *ethtool_ops;
#ifdef CONFIG_NET_L3_MASTER_DEV;
    const struct l3mdev_ops *l3mdev_ops;
#endif;
#if IS_ENABLED(CONFIG_IPV6);
    const struct ndisc_ops *ndisc_ops;
#endif;
#ifdef CONFIG_XFRM_OFFLOAD;
    const struct xfrmdev_ops *xfrmdev_ops;
#endif;
#if IS_ENABLED(CONFIG_TLS_DEVICE);
    const struct tlsdev_ops *tlsdev_ops;
#endif;
    unsigned int            operstate;
    unsigned char           link_mode;
    unsigned char           if_port;
    unsigned char           dma;
    unsigned char           perm_addr[MAX_ADDR_LEN];
    unsigned char           addr_assign_type;
    unsigned char           addr_len;
    unsigned char           upper_level;
    unsigned char           lower_level;
    unsigned short          neigh_priv_len;
    unsigned short          dev_id;
    unsigned short          dev_port;
    int irq;
    u32 priv_len;
    spinlock_t addr_list_lock;
    struct netdev_hw_addr_list      uc;
    struct netdev_hw_addr_list      mc;
    struct netdev_hw_addr_list      dev_addrs;
#ifdef CONFIG_SYSFS;
    struct kset             *queues_kset;
#endif;
#ifdef CONFIG_LOCKDEP;
    struct list_head        unlink_list;
#endif;
    unsigned int            promiscuity;
    unsigned int            allmulti;
    bool uc_promisc;
#ifdef CONFIG_LOCKDEP;
    unsigned char           nested_level;
#endif;
    struct in_device __rcu  *ip_ptr;
    struct hlist_head       fib_nh_head;
#if IS_ENABLED(CONFIG_VLAN_8021Q);
    struct vlan_info __rcu  *vlan_info;
#endif;
#if IS_ENABLED(CONFIG_NET_DSA);
    struct dsa_port         *dsa_ptr;
#endif;
#if IS_ENABLED(CONFIG_TIPC);
    struct tipc_bearer __rcu *tipc_ptr;
#endif;
#if IS_ENABLED(CONFIG_ATALK);
    void *atalk_ptr;
#endif;
#if IS_ENABLED(CONFIG_AX25);
    struct ax25_dev __rcu   *ax25_ptr;
#endif;
#if IS_ENABLED(CONFIG_CFG80211);
    struct wireless_dev     *ieee80211_ptr;
#endif;
#if IS_ENABLED(CONFIG_IEEE802154) || IS_ENABLED(CONFIG_6LOWPAN);
    struct wpan_dev         *ieee802154_ptr;
#endif;
#if IS_ENABLED(CONFIG_MPLS_ROUTING);
    struct mpls_dev __rcu   *mpls_ptr;
#endif;
#if IS_ENABLED(CONFIG_MCTP);
    struct mctp_dev __rcu   *mctp_ptr;
#endif;
    const unsigned char     *dev_addr;
    unsigned int            num_rx_queues;
#define GRO_LEGACY_MAX_SIZE     65536u;
#define GRO_MAX_SIZE            (8 * 65535u);
    unsigned int            xdp_zc_max_segs;
    struct netdev_queue __rcu *ingress_queue;
#ifdef CONFIG_NETFILTER_INGRESS;
    struct nf_hook_entries __rcu *nf_hooks_ingress;
#endif;
    unsigned char           broadcast[MAX_ADDR_LEN];
#ifdef CONFIG_RFS_ACCEL;
    struct cpu_rmap         *rx_cpu_rmap;
#endif;
    struct hlist_node       index_hlist;
    unsigned int            num_tx_queues;
    struct Qdisc __rcu      *qdisc;
    unsigned int            tx_queue_len;
    spinlock_t tx_global_lock;
    struct xdp_dev_bulk_queue __percpu *xdp_bulkq;
#ifdef CONFIG_NET_SCHED;
    unsigned long qdisc_hash[1 << ((4) - 1)];
#endif;
    struct timer_list       watchdog_timer;
    int watchdog_timeo;
    u32 proto_down_reason;
    struct list_head        todo_list;
#ifdef CONFIG_PCPU_DEV_REFCNT;
    int __percpu            *pcpu_refcnt;
#else;
    refcount_t dev_refcnt;
#endif;
    struct ref_tracker_dir  refcnt_tracker;
    struct list_head        link_watch_list;
    u8 reg_state;
    bool dismantle;
    bool moving_ns;
    bool rtnl_link_initializing;
    bool needs_free_netdev;
    void (*priv_destructor)(struct net_device *dev);
    void *ml_priv;
    enum netdev_ml_priv_type        ml_priv_type;
    enum netdev_stat_type           pcpu_stat_type:8;
#if IS_ENABLED(CONFIG_GARP);
    struct garp_port __rcu  *garp_port;
#endif;
#if IS_ENABLED(CONFIG_MRP);
    struct mrp_port __rcu   *mrp_port;
#endif;
#if IS_ENABLED(CONFIG_NET_DROP_MONITOR);
    struct dm_hw_stat_delta __rcu *dm_private;
#endif;
    struct device           dev;
    const struct attribute_group *sysfs_groups[4];
    const struct attribute_group *sysfs_rx_queue_group;
    const struct rtnl_link_ops *rtnl_link_ops;
    const struct netdev_stat_ops *stat_ops;
    const struct netdev_queue_mgmt_ops *queue_mgmt_ops;
#define GSO_MAX_SEGS            65535u;
#define GSO_LEGACY_MAX_SIZE     65536u;
#define GSO_MAX_SIZE            (8 * GSO_MAX_SEGS);
#define TSO_LEGACY_MAX_SIZE     65536;
#define TSO_MAX_SIZE            UINT_MAX;
    unsigned int            tso_max_size;
#define TSO_MAX_SEGS            U16_MAX;
    u16 tso_max_segs;
#ifdef CONFIG_DCB;
    const struct dcbnl_rtnl_ops *dcbnl_ops;
#endif;
    u8 prio_tc_map[TC_BITMASK + 1];
#if IS_ENABLED(CONFIG_FCOE);
    unsigned int            fcoe_ddp_xid;
#endif;
#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO);
    struct netprio_map __rcu *priomap;
#endif;
    struct phy_link_topology        *link_topo;
    struct phy_device       *phydev;
    struct sfp_bus          *sfp_bus;
    struct lock_class_key   *qdisc_tx_busylock;
    bool proto_down;
    bool threaded;
    bool irq_affinity_auto;
    bool rx_cpu_rmap_auto;
    unsigned long           see_all_hwtstamp_requests:1;
    unsigned long           change_proto_down:1;
    unsigned long           netns_immutable:1;
    unsigned long           fcoe_mtu:1;
    struct list_head        net_notifier_list;
#if IS_ENABLED(CONFIG_MACSEC);
    const struct macsec_ops *macsec_ops;
#endif;
    const struct udp_tunnel_nic_info        *udp_tunnel_nic_info;
    struct udp_tunnel_nic   *udp_tunnel_nic;
    struct netdev_config    *cfg;
    struct netdev_config    *cfg_pending;
    struct ethtool_netdev_state *ethtool;
    struct bpf_xdp_entity   xdp_state[__MAX_XDP_MODE];
    u8 dev_addr_shadow[MAX_ADDR_LEN];
    netdevice_tracker linkwatch_dev_tracker;
    netdevice_tracker watchdog_dev_tracker;
    netdevice_tracker dev_registered_tracker;
    struct rtnl_hw_stats64  *offload_xstats_l3;
    struct devlink_port     *devlink_port;
#if IS_ENABLED(CONFIG_DPLL);
    struct dpll_pin __rcu   *dpll_pin;
#endif;
#if IS_ENABLED(CONFIG_PAGE_POOL);
    struct hlist_head       page_pools;
#endif;
    struct dim_irq_moder    *irq_moder;
    u64 max_pacing_offload_horizon;
    struct napi_config      *napi_config;
    unsigned long           gro_flush_timeout;
    u32 napi_defer_hard_irqs;
    bool up;
    bool request_ops_lock;
    struct mutex            lock;
#if IS_ENABLED(CONFIG_NET_SHAPER);
    struct net_shaper_hierarchy *net_shaper_hierarchy;
#endif;
    struct hlist_head neighbours[NEIGH_NR_TABLES];
    struct hwtstamp_provider __rcu  *hwprov;
    u8 priv[]  ;
};

成員

priv_flags

對使用者空間不可見的標誌，定義為位，有關定義，請參閱 enum netdev_priv_flags

lltx

裝置支援無鎖 Tx。已棄用真正的 HW 驅動程式。主要由邏輯介面使用，例如 bonding 和隧道

netmem_tx

裝置支援 netmem_tx。

netdev_ops

包括指向回撥的多個指標，如果有人想覆蓋 ndo_*() 函式

header_ops

包括用於建立、解析、快取等第 2 層標頭的回撥。

_tx

TX 佇列陣列

gso_partial_features

來自 NETIF_F_GSO* 的值

real_num_tx_queues

裝置中當前活動的 TX 佇列數

gso_max_size

通用分段解除安裝的最大大小

gso_ipv4_max_size

IPv4 通用分段解除安裝的最大大小。

gso_max_segs

可以傳遞到 NIC 進行 GSO 的最大段數

num_tc

網路裝置中的流量類別數

mtu

介面 MTU 值

needed_headroom

硬體可能需要的額外頭空間，但在所有情況下都不能保證這一點

tc_to_txq

XXX：需要對此進行註釋

xps_maps

XXX：需要對此進行註釋

nf_hooks_egress

為出口資料包執行的 netfilter 鉤子

tcx_egress

用於出口處理的 BPF & clsact qdisc 特定資料

{unnamed_union}

匿名

lstats

環回統計資訊：資料包、位元組

tstats

隧道統計資訊：RX/TX 資料包、RX/TX 位元組

dstats

虛擬統計資訊：RX/TX/丟棄資料包、RX/TX 位元組

狀態

通用網路排隊層狀態，請參閱 netdev_state_t

標誌

介面標誌 (a la BSD)

hard_header_len

最大硬體標頭長度。

features

當前活動的裝置功能

ip6_ptr

IPv6 特定資料

xdp_prog

XDP 套接字過濾器程式指標

ptype_specific

裝置特定、協議特定的資料包處理程式

ifindex

介面索引

real_num_rx_queues

裝置中當前活動的 RX 佇列數

_rx

RX 佇列陣列

gro_max_size

通用接收解除安裝 (GRO) 中聚合資料包的最大大小

gro_ipv4_max_size

IPv4 通用接收解除安裝 (GRO) 中聚合資料包的最大大小。

rx_handler

接收資料包的處理程式

rx_handler_data

XXX：需要對此進行註釋

nd_net

此網路裝置所在的網路名稱空間，受 lock 保護

npinfo

XXX：需要對此進行註釋

tcx_ingress

用於入口處理的 BPF & clsact qdisc 特定資料

name

這是此結構的“可見”部分（即使用者在“Space.c”檔案中看到的）的第一個欄位。它是介面的名稱。

name_node

名稱雜湊列表節點

ifalias

SNMP 別名

mem_end

共享記憶體結束

mem_start

共享記憶體開始

base_addr

裝置 I/O 地址

dev_list

網路裝置的全域性列表

napi_list

用於輪詢 NAPI 裝置的列表條目

unreg_list

我們正在登出裝置時的列表條目；請參閱函式 unregister_netdev

close_list

當我們正在關閉裝置時使用的列表條目

ptype_all

所有協議的裝置特定資料包處理程式

adj_list

直接連結的裝置，例如 bonding 的從裝置

xdp_features

裝置支援的 XDP 功能

xdp_metadata_ops

包括指向 XDP 元資料回撥的指標。

xsk_tx_metadata_ops

包括指向 AF_XDP TX 元資料回撥的指標。

gflags

全域性標誌（保留為舊版）

needed_tailroom

硬體可能需要的額外尾部空間，但在所有情況下都不能保證這一點。某些情況下也使用 LL_MAX_HEADER 來分配 skb

介面地址資訊

hw_features

使用者可更改的功能

wanted_features

使用者請求的功能

vlan_features

VLAN 裝置可繼承的功能掩碼

hw_enc_features

封裝裝置可繼承的功能掩碼。此欄位指示硬體能夠進行哪些封裝解除安裝，驅動程式需要適當地設定它們。

mpls_features

MPLS 可繼承的功能掩碼

min_mtu

介面最小 MTU 值

max_mtu

介面最大 MTU 值

型別

type

介面硬體型別

min_header_len

最小硬體標頭長度

name_assign_type

網路介面名稱分配型別

group

裝置所屬的組

stats

統計資訊結構，它被保留為舊版，請改用 rtnl_link_stats64

core_stats

核心網路計數器，請勿在驅動程式中使用此計數器

carrier_up_count

載波已啟動的次數

carrier_down_count

載波已關閉的次數

wireless_handlers

用於處理無線擴充套件的函式列表，而不是 ioctl，有關詳細資訊，請參閱 <net/iw_handler.h>。

ethtool_ops

管理操作

l3mdev_ops

第 3 層主裝置操作

ndisc_ops

包括用於不同 IPv6 鄰居發現處理的回撥。例如，6LoWPAN 所必需。

xfrmdev_ops

轉換解除安裝操作

tlsdev_ops

傳輸層安全解除安裝操作

operstate

RFC2863 operstate

link_mode

策略到 operstate 的對映

if_port

可選的 AUI、TP、...

dma

DMA 通道

perm_addr

永久 hw 地址

addr_assign_type

Hw 地址分配型別

addr_len

硬體地址長度

upper_level

上層裝置的最大深度級別。

lower_level

下層裝置的最大深度級別。

neigh_priv_len

在 neigh_alloc() 中使用

dev_id

用於區分共享相同鏈路層地址的裝置

dev_port

用於區分共享相同功能的裝置

irq

裝置 IRQ 編號

priv_len

->priv 靈活陣列的大小

XXX：需要對此進行註釋

addr_list_lock

uc

單播 mac 地址

mc

多播 mac 地址

dev_addrs

裝置 hw 地址列表

queues_kset

Tx 和 RX 佇列中所有 Kobject 的組

unlink_list

由於可以遞迴呼叫 netif_addr_lock()，因此請保留要刪除的介面列表。

promiscuity

NIC 被告知以混雜模式工作的次數；如果變為 0，則 NIC 將退出混雜模式

allmulti

計數器，啟用或停用 allmulticast 模式

uc_promisc

計數器，指示由於需要在不實現 ndo_set_rx_mode() 的裝置中偵聽其他單播地址，因此已啟用混雜模式

nested_level

用作 dev->addr_list_lock 的 spin_lock_nested() 的引數。

ip_ptr

IPv4 特定資料

fib_nh_head

與此 netdev 關聯的下一跳

vlan_info

VLAN 資訊

dsa_ptr

dsa 特定資料

tipc_ptr

TIPC 特定資料

atalk_ptr

AppleTalk 連結

ax25_ptr

AX.25 特定資料

ieee80211_ptr

IEEE 802.11 特定資料，在註冊之前分配

ieee802154_ptr

IEEE 802.15.4 低速率無線個人區域網路裝置結構

mpls_ptr

mpls_dev 結構指標

mctp_ptr

MCTP 特定資料

dev_addr

Hw 地址（在 bcast 之前，因為大多數資料包都是單播）

num_rx_queues

在 register_netdev() 時分配的 RX 佇列數

xdp_zc_max_segs

AF_XDP 零複製驅動程式支援的最大段數

XXX：需要對此進行註釋

ingress_queue

nf_hooks_ingress

為入口資料包執行的 netfilter 鉤子

broadcast

hw 廣播地址

rx_cpu_rmap

RX 完成中斷的 CPU 反向對映，按 RX 佇列編號索引。由驅動程式分配。只有在定義了 ndo_rx_flow_steer 操作時才必須設定此值

index_hlist

裝置索引雜湊鏈

num_tx_queues

在 alloc_netdev_mq() 時分配的 TX 佇列數

qdisc

從使用者空間角度來看的根 qdisc

tx_queue_len

允許的每個佇列的最大幀數

XXX：需要對此進行註釋

tx_global_lock

xdp_bulkq

XDP 裝置批次佇列

qdisc_hash

qdisc 雜湊表

watchdog_timer

計時器列表

watchdog_timeo

表示 watchdog 使用的超時（請參閱 dev_watchdog()）

proto_down_reason

netdev 介面被停用的原因

todo_list

延遲註冊/登出

pcpu_refcnt

對此裝置的引用數

pcpu_refcnt

dev_refcnt

refcnt_tracker

用於跟蹤此裝置的跟蹤引用的跟蹤器目錄

XXX：需要對此進行註釋

link_watch_list

reg_state

註冊/登出狀態機

dismantle

裝置將被釋放

moving_ns

裝置正在更改 netns，受 lock 保護

rtnl_link_initializing

正在建立裝置，禁止事件

needs_free_netdev

登出是否應執行 free_netdev？

priv_destructor

從登出呼叫

ml_priv

中間層私有

ml_priv_type

中間層私有型別

pcpu_stat_type

核心應分配/釋放的裝置統計資訊型別：none、lstats、tstats、dstats。none 表示驅動程式在內部處理統計資訊分配/釋放。

garp_port

GARP

mrp_port

MRP

dm_private

dev

丟棄監視器私有

Class/net/name 條目

sysfs_groups

用於可選裝置、統計資訊和無線 sysfs 組的空間

sysfs_rx_queue_group

用於可選的每個 rx 佇列屬性的空間

rtnl_link_ops

Rtnl_link_ops

stat_ops

用於佇列感知統計資訊的可選操作

queue_mgmt_ops

用於佇列管理的可選操作

tso_max_size

裝置（如 HW）對最大 TSO 請求大小的限制

tso_max_segs

裝置（如 HW）對最大 TSO 段數的限制

dcbnl_ops

資料中心橋接 netlink 操作

XXX：需要對此進行註釋

prio_tc_map

fcoe_ddp_xid

用於 FCoE LRO by ddp 的最大交換 ID

XXX：需要對此進行註釋

priomap

link_topo

物理鏈路拓撲跟蹤連線的 PHY

phydev

物理裝置可以自行附加以進行硬體時間戳

sfp_bus

附加的 struct sfp_bus 結構。

qdisc_tx_busylock

註釋 Qdisc->busylock 自旋鎖的 lockdep 類

proto_down

協議埠狀態資訊可以傳送到交換機驅動程式，並用於設定交換機埠的 phys 狀態。

threaded

已啟用 napi 執行緒模式

irq_affinity_auto

驅動程式希望核心儲存並重新分配 IRQ 親和性。由 netif_enable_irq_affinity() 設定，然後驅動程式必須透過 netif_napi_add_config() 建立持久 napi，最後將 napi 繫結到 IRQ（透過 netif_napi_set_irq()）。

rx_cpu_rmap_auto

驅動程式希望核心管理 ARFS rmap。透過呼叫 netif_enable_cpu_rmap() 設定。

see_all_hwtstamp_requests

裝置希望檢視對 ndo_hwtstamp_set() 的呼叫，以獲取所有時間戳請求，無論來源如何，即使這些請求不是 HWTSTAMP_SOURCE_NETDEV

change_proto_down

裝置支援透過 IFLA_PROTO_DOWN 設定載波

netns_immutable

介面無法更改網路名稱空間

fcoe_mtu

裝置支援最大 FCoE MTU，2158 位元組

net_notifier_list

當裝置移動到另一個網路名稱空間時，遵循此裝置的每個網路 netdev 通知程式塊的列表。

macsec_ops

MACsec 解除安裝操作

udp_tunnel_nic_info

描述裝置的 UDP 隧道解除安裝功能的靜態結構

udp_tunnel_nic

UDP 隧道解除安裝狀態

cfg

net_device 佇列相關配置

cfg_pending: 與 cfg 相同，但當裝置處於活動狀態時

重新配置包括使用者請求的對配置的任何更改，但這些更改可能會被拒絕。

ethtool

ethtool 相關狀態

xdp_state

儲存有關附加的 XDP BPF 程式的資訊

dev_addr_shadow

dev_addr 的副本，用於捕獲直接寫入。

linkwatch_dev_tracker

linkwatch 使用的 refcount 跟蹤器。

watchdog_dev_tracker

watchdog 使用的 refcount 跟蹤器。

dev_registered_tracker

用於在註冊時儲存引用的跟蹤器

offload_xstats_l3

此 netdevice 的 L3 HW 統計資訊。

devlink_port

指向相關 devlink 埠結構的指標。在 netdev 註冊之前由驅動程式使用 SET_NETDEV_DEVLINK_PORT 宏分配。此指標在 netdevice 註冊期間是靜態的。

dpll_pin

指向 DPLL 子系統的 SyncE 源引腳的指標，其中時鐘已恢復。

page_pools

為此 netdevice 建立的頁面池

irq_moder

如果 IS_ENABLED(CONFIG_DIMLIB)，則使用 dim 引數。

max_pacing_offload_horizon

最大 EDT 解除安裝範圍，單位為 nsec。

napi_config

napi_config 結構的陣列，包含每個 NAPI 的設定。

gro_flush_timeout

NAPI 中 GRO 層的超時

napi_defer_hard_irqs

如果非零，則提供一個計數器，該計數器可以在繁忙的佇列上避免 NIC 硬中斷。

up: state 的 IFF_UP 的副本，但可以安全讀取，只需 lock。

在開啟或關閉裝置時可能會報告假陰性（lock 不保護 .ndo_open 或 .ndo_close）。

request_ops_lock

請求核心在 lock 下執行所有 netdev_ops 和 ethtool_ops。

lock

netdev 範圍的鎖，保護少量欄位。應始終使用 netdev_lock() / netdev_unlock() 幫助程式獲取。驅動程式可以自由地使用它進行其他保護。

對於實現整形器或佇列 API 的驅動程式，此鎖的範圍已擴充套件為涵蓋大多數 ndo/queue/ethtool/sysfs 操作。驅動程式可以透過設定 request_ops_lock 來選擇此行為。

lock 保護以多種方式與 rtnl_lock 混合，欄位可以是
僅由例項 lock 保護；
雙重保護 - 寫入者同時持有兩個鎖，讀取者持有其中一個；
ops 保護 - 受圍繞 NDO 和其他回撥持有的鎖保護，對於 netdev_need_ops_lock() 返回 true 的裝置，它是例項鎖，否則由 rtnl_lock 保護；

雙重 ops 保護 - 始終由 rtnl_lock 保護，但對於 netdev_need_ops_lock() 返回 true 的裝置 - 也由例項鎖保護。: 簡單地保護
gro_flush_timeout、napi_defer_hard_irqs、napi_list、net_shaper_hierarchy、reg_state、threaded: 雙重保護
up、moving_ns、nd_net、xdp_features: 雙重 ops 保護
real_num_rx_queues、real_num_tx_queues: 還保護一些欄位

struct napi_struct、struct netdev_queue、struct netdev_rx_queue

排序：在 rtnl_lock 之後獲取。

net_shaper_hierarchy: 跟蹤當前整形器狀態的資料

請參閱 include/net/net_shapers.h

neighbours

指向此裝置的鄰居的 dev_list 的列表頭，每個地址族一個。

hwprov

跟蹤哪個 PTP 執行硬體資料包時間戳。

FIXME：清理 struct net_device，以便網路協議資訊移出。

priv

描述

包含私有資料的靈活陣列

實際上，整個結構是一個很大的錯誤。它將 I/O 資料與嚴格的“高階”資料混合在一起，並且必須瞭解 INET 模組中使用的幾乎每個資料結構。: void *netdev_priv(const struct net_device *dev)¶

引數

const struct net_device *dev: 網路裝置

描述

訪問網路裝置私有資料

獲取網路裝置私有資料: void netif_napi_add(struct net_device *dev, struct napi_struct *napi, int (*poll)(struct napi_struct*, int))¶

引數

struct net_device *dev: 網路裝置
struct napi_struct *napi: NAPI 上下文
初始化 NAPI 上下文: int (*poll)(struct napi_struct *, int)

描述

輪詢函式

必須使用 netif_napi_add() 來初始化 NAPI 上下文，然後才能呼叫任何其他 NAPI 相關函式。: void netif_napi_add_config(struct net_device *dev, struct napi_struct *napi, int (*poll)(struct napi_struct*, int), int index)¶

引數

struct net_device *dev: 網路裝置
struct napi_struct *napi: NAPI 上下文
初始化 NAPI 上下文: int (*poll)(struct napi_struct *, int)
使用持久配置初始化 NAPI 上下文: int index

NAPI 索引: void netif_napi_add_tx(struct net_device *dev, struct napi_struct *napi, int (*poll)(struct napi_struct*, int))¶

引數

struct net_device *dev: 網路裝置
struct napi_struct *napi: NAPI 上下文
初始化 NAPI 上下文: int (*poll)(struct napi_struct *, int)

描述

初始化 NAPI 上下文，僅用於 Tx

netif_napi_add() 的此變體應由使用 NAPI 專門輪詢 TX 佇列的驅動程式使用。這將避免我們將其新增到 napi_hash[] 中，從而汙染此雜湊表。: void __netif_napi_del(struct napi_struct *napi)¶

引數

struct napi_struct *napi: NAPI 上下文

描述

刪除 NAPI 上下文

void netif_napi_del(struct napi_struct *napi)¶: void __netif_napi_del(struct napi_struct *napi)¶

引數

struct napi_struct *napi

NAPI 上下文

netif_napi_del() 從網路裝置 NAPI 列表中移除 NAPI 上下文

void netif_start_queue(struct net_device *dev)¶: 允許傳送

引數

struct net_device *dev

網路裝置

允許上層呼叫裝置的 hard_start_xmit 例程。

void netif_wake_queue(struct net_device *dev)¶: 重新啟動傳送

引數

struct net_device *dev

網路裝置

允許上層呼叫裝置的 hard_start_xmit 例程。當傳送資源可用時，用於流量控制。

void netif_stop_queue(struct net_device *dev)¶: 停止傳送的資料包

引數

struct net_device *dev

網路裝置

停止上層呼叫裝置的 hard_start_xmit 例程。當傳送資源不可用時，用於流量控制。

bool netif_queue_stopped(const struct net_device *dev)¶: 測試傳送佇列是否被流控阻塞

引數

const struct net_device *dev

網路裝置

測試裝置上的傳送隊列當前是否無法傳送。

void netdev_queue_set_dql_min_limit(struct netdev_queue *dev_queue, unsigned int min_limit)¶: 設定 dql 最小限制

引數

struct netdev_queue *dev_queue: 傳送佇列的指標
unsigned int min_limit: dql 最小限制

描述

強制 xmit_more() 返回 true，直到達到 min_limit 定義的最小閾值（或者直到 tx 佇列為空）。警告：小心使用，濫用會影響延遲。

void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)¶: 預取 bql 資料以進行寫入

引數

struct netdev_queue *dev_queue: 傳送佇列的指標

描述

啟用 BQL 的驅動程式可以在其 ndo_start_xmit() 中使用此助手，以便為 CPU 提供適當的提示。

void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)¶: 預取 bql 資料以進行寫入

引數

struct netdev_queue *dev_queue: 傳送佇列的指標

描述

啟用 BQL 的驅動程式可以在其 TX 完成路徑中使用此助手，以便為 CPU 提供適當的提示。

void netdev_tx_sent_queue(struct netdev_queue *dev_queue, unsigned int bytes)¶: 報告已排隊到給定 tx 佇列的位元組數

引數

struct netdev_queue *dev_queue

網路裝置佇列

unsigned int bytes

排隊到裝置佇列的位元組數

報告為傳送/完成而排隊到網路裝置硬體佇列的位元組數。 bytes 應該是一個很好的近似值，並且應該與 netdev_completed_queue() bytes 完全匹配。這通常在 ndo_start_xmit() 中每個資料包呼叫一次。

void netdev_sent_queue(struct net_device *dev, unsigned int bytes)¶: 報告排隊到硬體的位元組數

引數

struct net_device *dev

網路裝置

unsigned int bytes

排隊到硬體裝置佇列的位元組數

報告為傳送/完成而排隊到網路裝置硬體佇列 #0 的位元組數。 bytes 應該是一個很好的近似值，並且應該與 netdev_completed_queue() bytes 完全匹配。這通常在 ndo_start_xmit() 中每個資料包呼叫一次。

void netdev_tx_completed_queue(struct netdev_queue *dev_queue, unsigned int pkts, unsigned int bytes)¶: 報告 TX 完成時的資料包/位元組數。

引數

struct netdev_queue *dev_queue

網路裝置佇列

unsigned int pkts

資料包數（當前已忽略）

unsigned int bytes

從裝置佇列中出隊的位元組數

每次 TX 完成迴圈最多隻能呼叫一次（而不是每個單獨的資料包呼叫一次），以便 BQL 可以適當地調整其限制。

void netdev_completed_queue(struct net_device *dev, unsigned int pkts, unsigned int bytes)¶: 報告裝置完成的位元組數和資料包數

引數

struct net_device *dev

網路裝置

unsigned int pkts

透過介質傳送的實際資料包數

unsigned int bytes

透過介質傳送的實際位元組數

報告網路裝置硬體佇列透過物理介質傳輸的位元組數和資料包數，bytes 必須與傳遞給 netdev_sent_queue() 的 bytes 量完全匹配

void netdev_tx_reset_subqueue(const struct net_device *dev, u32 qid)¶: 重置 netdev 佇列的 BQL 統計資訊和狀態

引數

const struct net_device *dev: 網路裝置
u32 qid: 要重置的佇列的堆疊索引

void netdev_reset_queue(struct net_device *dev_queue)¶: 重置網路裝置的資料包和位元組計數

引數

struct net_device *dev_queue

網路裝置

重置網路裝置的位元組數和資料包計數，並清除此網路裝置的軟體流控制 OFF 位

u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)¶: 檢查所選 tx 佇列是否超過裝置佇列

引數

struct net_device *dev

網路裝置

u16 queue_index

給定的 tx 佇列索引

如果給定的 tx 佇列索引 >= 裝置 tx 佇列的數量，則返回 0，否則返回原始傳遞的 tx 佇列索引。

bool netif_running(const struct net_device *dev)¶: 測試是否啟動

引數

const struct net_device *dev

網路裝置

測試裝置是否已啟動。

void netif_start_subqueue(struct net_device *dev, u16 queue_index)¶: 允許在子佇列上傳送資料包

引數

struct net_device *dev: 網路裝置
u16 queue_index: 子佇列索引

描述

啟動具有多個傳送佇列的裝置的單個傳送佇列。

void netif_stop_subqueue(struct net_device *dev, u16 queue_index)¶: 停止在子佇列上傳送資料包

引數

struct net_device *dev: 網路裝置
u16 queue_index: 子佇列索引

描述

停止具有多個傳送佇列的裝置的單個傳送佇列。

bool __netif_subqueue_stopped(const struct net_device *dev, u16 queue_index)¶: 測試子佇列的狀態

引數

const struct net_device *dev: 網路裝置
u16 queue_index: 子佇列索引

描述

檢查具有多個傳送佇列的裝置的單個傳送佇列。

bool netif_subqueue_stopped(const struct net_device *dev, struct sk_buff *skb)¶: 測試子佇列的狀態

引數

const struct net_device *dev: 網路裝置
設定 skb dst: 子佇列緩衝區指標

描述

檢查具有多個傳送佇列的裝置的單個傳送佇列。

void netif_wake_subqueue(struct net_device *dev, u16 queue_index)¶: 允許在子佇列上傳送資料包

引數

struct net_device *dev: 網路裝置
u16 queue_index: 子佇列索引

描述

恢復具有多個傳送佇列的裝置的單個傳送佇列。

bool netif_attr_test_mask(unsigned long j, const unsigned long *mask, unsigned int nr_bits)¶: 測試掩碼中設定的 CPU 或 Rx 佇列

引數

unsigned long j: CPU/Rx 佇列索引
const unsigned long *mask: 所有 cpu/rx 佇列的位掩碼
unsigned int nr_bits: 位掩碼中的位數

描述

測試 CPU 或 Rx 佇列索引是否在所有 CPU/Rx 佇列的掩碼中設定。

bool netif_attr_test_online(unsigned long j, const unsigned long *online_mask, unsigned int nr_bits)¶: 測試線上 CPU/Rx 佇列

引數

unsigned long j: CPU/Rx 佇列索引
const unsigned long *online_mask: 線上的 CPU/Rx 佇列的位掩碼
unsigned int nr_bits: 位掩碼中的位數

返回 skb dst_entry

如果 CPU/Rx 佇列線上，則為 true。

unsigned int netif_attrmask_next(int n, const unsigned long *srcp, unsigned int nr_bits)¶: 獲取 cpu/Rx 佇列掩碼中的下一個 CPU/Rx 佇列

引數

int n: CPU/Rx 佇列索引
const unsigned long *srcp: cpumask/Rx 佇列掩碼指標
unsigned int nr_bits: 位掩碼中的位數

返回 skb dst_entry

掩碼中的下一個（在 n 之後）CPU/Rx 佇列索引；如果沒有設定更多的 CPU/Rx 佇列，則 >= nr_bits。

int netif_attrmask_next_and(int n, const unsigned long *src1p, const unsigned long *src2p, unsigned int nr_bits)¶: 在 *src1p & *src2p 中獲取下一個 CPU/Rx 佇列

引數

int n: CPU/Rx 佇列索引
const unsigned long *src1p: 第一個 CPUs/Rx 佇列掩碼指標
const unsigned long *src2p: 第二個 CPUs/Rx 佇列掩碼指標
unsigned int nr_bits: 位掩碼中的位數

返回 skb dst_entry

兩個掩碼中設定的下一個（在 n 之後）CPU/Rx 佇列索引；如果兩個中都沒有設定更多的 CPU/Rx 佇列，則 >= nr_bits。

bool netif_is_multiqueue(const struct net_device *dev)¶: 測試裝置是否具有多個傳送佇列

引數

const struct net_device *dev: 網路裝置

描述

檢查裝置是否具有多個傳送佇列

void dev_hold(struct net_device *dev)¶: 獲取對裝置的引用

引數

struct net_device *dev: 網路裝置

描述

保持對裝置的引用，以防止它被釋放。嘗試使用 netdev_hold() 代替。

void dev_put(struct net_device *dev)¶: 釋放對裝置的引用

引數

struct net_device *dev: 網路裝置

描述

釋放對裝置的引用以允許釋放它。嘗試使用 netdev_put() 代替。

void linkwatch_sync_dev(struct net_device *dev)¶: 同步給定裝置的 linkwatch

引數

struct net_device *dev: 要同步 linkwatch 的網路裝置

描述

同步給定裝置的 linkwatch，將其從掛起工作列表中移除（如果已排隊）。

bool netif_carrier_ok(const struct net_device *dev)¶: 測試載波是否已連線

引數

const struct net_device *dev: 網路裝置

描述

檢查裝置上是否已連線載波

void netif_dormant_on(struct net_device *dev)¶: 將裝置標記為休眠。

引數

struct net_device *dev: 網路裝置

描述

將裝置標記為休眠（根據 RFC2863）。

休眠狀態表示相關介面實際上並未處於傳遞資料包的條件（即，它未“啟動”），而是處於“掛起”狀態，等待某些外部事件。對於“按需”介面，這種新狀態標識了介面正在等待事件將其置於啟動狀態的情況。

void netif_dormant_off(struct net_device *dev)¶: 將裝置設定為非休眠。

引數

struct net_device *dev: 網路裝置

描述

裝置未處於休眠狀態。

bool netif_dormant(const struct net_device *dev)¶: 測試裝置是否休眠

引數

const struct net_device *dev: 網路裝置

描述

檢查裝置是否休眠。

void netif_testing_on(struct net_device *dev)¶: 將裝置標記為正在測試。

引數

struct net_device *dev: 網路裝置

描述

將裝置標記為正在測試（根據 RFC2863）。

測試狀態表示必須在介面上執行一些測試。完成測試後，介面狀態將根據需要更改為啟動、休眠或關閉。

void netif_testing_off(struct net_device *dev)¶: 將裝置設定為未在測試中。

引數

struct net_device *dev: 網路裝置

描述

裝置未處於測試狀態。

bool netif_testing(const struct net_device *dev)¶: 測試裝置是否正在測試中

引數

const struct net_device *dev: 網路裝置

描述

檢查裝置是否正在測試中

bool netif_oper_up(const struct net_device *dev)¶: 測試裝置是否可操作

引數

const struct net_device *dev: 網路裝置

描述

檢查載波是否可操作

bool netif_device_present(const struct net_device *dev)¶: 裝置是否可用或已移除

引數

const struct net_device *dev: 網路裝置

描述

檢查裝置是否已從系統中移除。

void netif_tx_lock(struct net_device *dev)¶: 獲取網路裝置傳送鎖

引數

struct net_device *dev: 網路裝置

描述

獲取網路裝置傳送鎖

int __dev_uc_sync(struct net_device *dev, int (*sync)(struct net_device*, const unsigned char*), int (*unsync)(struct net_device*, const unsigned char*))¶: 同步裝置的單播列表

引數

struct net_device *dev

要同步的裝置

int (*sync)(struct net_device *, const unsigned char *)

如果應新增地址，則呼叫的函式

int (*unsync)(struct net_device *, const unsigned char *)

如果應移除地址，則呼叫的函式

將新新增的地址新增到介面，並釋放已刪除的地址。

void __dev_uc_unsync(struct net_device *dev, int (*unsync)(struct net_device*, const unsigned char*))¶: 從裝置中移除同步的地址

引數

struct net_device *dev

要同步的裝置

int (*unsync)(struct net_device *, const unsigned char *)

如果應移除地址，則呼叫的函式

移除所有由 dev_uc_sync() 新增到裝置的地址。

int __dev_mc_sync(struct net_device *dev, int (*sync)(struct net_device*, const unsigned char*), int (*unsync)(struct net_device*, const unsigned char*))¶: 同步裝置的多播列表

引數

struct net_device *dev

要同步的裝置

int (*sync)(struct net_device *, const unsigned char *)

如果應新增地址，則呼叫的函式

int (*unsync)(struct net_device *, const unsigned char *)

如果應移除地址，則呼叫的函式

將新新增的地址新增到介面，並釋放已刪除的地址。

void __dev_mc_unsync(struct net_device *dev, int (*unsync)(struct net_device*, const unsigned char*))¶: 從裝置中移除同步的地址

引數

struct net_device *dev

要同步的裝置

int (*unsync)(struct net_device *, const unsigned char *)

如果應移除地址，則呼叫的函式

移除所有由 dev_mc_sync() 新增到裝置的地址。

struct net_shaper¶: 表示 NIC H/W 上的整形節點，零值欄位被認為未設定。

定義:

struct net_shaper {
    struct net_shaper_handle parent;
    struct net_shaper_handle handle;
    enum net_shaper_metric metric;
    u64 bw_min;
    u64 bw_max;
    u64 burst;
    u32 priority;
    u32 weight;
};

成員

父節點: 整形器父節點的唯一識別符號，通常是隱含的
控制代碼: 此整形器的唯一識別符號
指標: 指定速率限制是指 PPS 還是 BPS
bw_min: 此整形器的最小保證速率
bw_max: 此整形器允許的最大峰值速率
突發: 此整形器的峰值速率的最大突發
應儲存校驗和的從 csum_start 開始的偏移量: 此整形器的排程優先順序
權重: 此整形器的排程權重

struct net_shaper_ops¶: 裝置 H/W 整形器的操作

定義:

struct net_shaper_ops {
    int (*group)(struct net_shaper_binding *binding, int leaves_count,const struct net_shaper *leaves,const struct net_shaper *node, struct netlink_ext_ack *extack);
    int (*set)(struct net_shaper_binding *binding,const struct net_shaper *shaper, struct netlink_ext_ack *extack);
    int (*delete)(struct net_shaper_binding *binding,const struct net_shaper_handle *handle, struct netlink_ext_ack *extack);
    void (*capabilities)(struct net_shaper_binding *binding, enum net_shaper_scope scope, unsigned long *cap);
};

成員

網路介面名稱分配型別

建立指定的整形器排程組

將 leaves 整形器（由 node 整形器標識）巢狀。所有整形器都屬於 binding 指定的裝置。leaves 陣列的大小由 leaves_count 指定。建立 leaves 和 node 整形器；或者，如果它們已經存在，則以期望的方式將它們連結在一起。leaves 的作用域必須是 NET_SHAPER_SCOPE_QUEUE。

設定

更新指定的整形器

更新或建立 shaper 在 binding 指定的裝置上。

刪除

移除指定的整形器

移除由給定的 handle 標識的整形器配置，該配置在 binding 指定的裝置上，恢復預設行為。

功能

獲取裝置支援的整形器特性

使用 binding 指定的裝置的指定 scope 的支援功能填充位掩碼 cap。

描述

這些操作適用於 net_device 和 devlink 物件。裝置初始化時的初始整形配置為空：不以任何方式約束速率。網路核心在 net_device 或 devlink 結構中跟蹤應用的使用者配置。這些操作透過每個裝置的鎖進行序列化。

不支援任何巢狀的裝置不應提供組操作。

每個整形器在裝置中都使用 “handle” 唯一標識，該 “handle” 包括整形器作用域和特定於作用域的 ID。

PHY 支援¶

void phy_print_status(struct phy_device *phydev)¶: 列印當前 PHY 狀態的便捷函式

引數

struct phy_device *phydev: phy_device 結構

int phy_get_rate_matching(struct phy_device *phydev, phy_interface_t iface)¶: 確定是否支援速率匹配

引數

struct phy_device *phydev: 要返回速率匹配的 PHY 裝置
phy_interface_t iface: 要使用的介面模式

描述

這確定了 phy 使用 iface 支援的速率匹配型別（如果有）。iface 可以是 PHY_INTERFACE_MODE_NA，以確定任何介面是否支援速率匹配。

返回 skb dst_entry

phy 為 iface 支援的速率匹配型別，或: RATE_MATCH_NONE.

int phy_restart_aneg(struct phy_device *phydev)¶: 重新啟動自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

重新啟動 phydev 上的自動協商。成功返回 >= 0，錯誤返回負 errno。

int phy_aneg_done(struct phy_device *phydev)¶: 返回自動協商狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從此 phydev 返回自動協商狀態。成功返回 > 0，錯誤返回 < 0。0 表示自動協商仍在進行中。

bool phy_check_valid(int speed, int duplex, unsigned long *features)¶: 檢查是否存在與速度、雙工和特性掩碼匹配的有效 PHY 設定

引數

int speed: 要匹配的速度
int duplex: 要匹配的雙工模式
unsigned long *features: 有效設定的掩碼

描述

如果存在有效設定，則返回 true，否則返回 false。

int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd)¶: 通用 PHY MII ioctl 介面

引數

struct phy_device *phydev: phy_device 結構
struct ifreq *ifr: struct ifreq 用於套接字 ioctl
int cmd: 要執行的 ioctl cmd

描述

請注意，此函式當前與 PHYCONTROL 層不相容。它更改暫存器而不考慮當前狀態。使用風險自負。

int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)¶: 通用 ndo_eth_ioctl 實現

引數

struct net_device *dev: net_device 結構
struct ifreq *ifr: struct ifreq 用於套接字 ioctl
int cmd: 要執行的 ioctl cmd

int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd)¶: 通用 ndo_eth_ioctl 實現，但首先進行測試

引數

struct net_device *dev: net_device 結構
struct ifreq *ifr: struct ifreq 用於套接字 ioctl
int cmd: 要執行的 ioctl cmd

描述

與 phy_do_ioctl 相同，但在處理 ioctl 之前確保 net_device 正在執行。

void phy_trigger_machine(struct phy_device *phydev)¶: 立即觸發狀態機執行

引數

struct phy_device *phydev: phy_device 結構

int phy_ethtool_get_strings(struct phy_device *phydev, u8 *data)¶: 獲取統計計數器名稱

引數

struct phy_device *phydev: phy_device 結構
u8 *data: 放置字串的位置

int phy_ethtool_get_sset_count(struct phy_device *phydev)¶: 獲取統計計數器的數量

引數

struct phy_device *phydev: phy_device 結構

int phy_ethtool_get_stats(struct phy_device *phydev, struct ethtool_stats *stats, u64 *data)¶: 獲取統計計數器

引數

struct phy_device *phydev: phy_device 結構
struct ethtool_stats *stats: 要獲取的計數器
u64 *data: 儲存計數器的位置

int phy_start_cable_test(struct phy_device *phydev, struct netlink_ext_ack *extack)¶: 啟動電纜測試

引數

struct phy_device *phydev: phy_device 結構
struct netlink_ext_ack *extack: 用於報告有用錯誤訊息的 extack

int phy_start_cable_test_tdr(struct phy_device *phydev, struct netlink_ext_ack *extack, const struct phy_tdr_config *config)¶: 啟動原始 TDR 電纜測試

引數

struct phy_device *phydev: phy_device 結構
struct netlink_ext_ack *extack: 用於報告有用錯誤訊息的 extack
const struct phy_tdr_config *config: 要執行的測試的配置

unsigned int phy_inband_caps(struct phy_device *phydev, phy_interface_t interface)¶: 查詢支援哪些帶內信令模式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
phy_interface_t interface: PHY 的介面模式

描述

如果不知道 PHY 支援哪些帶內信令（例如，因為 PHY 驅動程式未實現該方法），則返回零。否則，返回 enum link_inband_signalling 中的 LINK_INBAND_* 值的位掩碼，以描述 PHY 在此介面模式下支援哪些帶內模式。

int phy_config_inband(struct phy_device *phydev, unsigned int modes)¶: 配置所需的 PHY 帶內模式

引數

struct phy_device *phydev: phy_device 結構
unsigned int modes: 要配置的帶內模式

描述

停用、啟用或啟用帶旁路的帶內信令: 在 PHY 和主機系統之間。

返回 skb dst_entry

成功返回零，或返回負 errno 值。

int _phy_start_aneg(struct phy_device *phydev)¶: 為此 PHY 裝置啟動自動協商

引數

struct phy_device *phydev: phy_device 結構

描述

清理設定（如果我們沒有自動協商: 它們），然後呼叫驅動程式的 config_aneg 函式。如果 PHYCONTROL 層正在執行，我們將更改狀態以反映自動協商或強制的開始。

int phy_start_aneg(struct phy_device *phydev)¶: 為此 PHY 裝置啟動自動協商

引數

struct phy_device *phydev: phy_device 結構

描述

清理設定（如果我們沒有自動協商: 它們），然後呼叫驅動程式的 config_aneg 函式。如果 PHYCONTROL 層正在執行，我們將更改狀態以反映自動協商或強制的開始。

int phy_speed_down(struct phy_device *phydev, bool sync)¶: 將速度設定為鏈路雙方支援的最低速度

引數

struct phy_device *phydev: phy_device 結構
bool sync: 同步執行操作

描述

通常用於在等待 WoL 資料包時節省能源

警告：如果將 sync 設定為 false，則在 PHY 完成自動協商時生成中斷的情況下，可能會導致系統無法掛起。此中斷可能會在掛起後立即喚醒系統。因此，僅當您確定對於相應的網路晶片是安全的情況下，才使用 sync = false。

int phy_speed_up(struct phy_device *phydev)¶: （重新）將通告的速度設定為所有支援的速度

引數

struct phy_device *phydev: phy_device 結構

描述

用於恢復 phy_speed_down 的效果

void phy_start_machine(struct phy_device *phydev)¶: 啟動 PHY 狀態機跟蹤

引數

struct phy_device *phydev: phy_device 結構

描述

PHY 基礎設施可以執行一個狀態機: 它跟蹤 PHY 是啟動、協商等。此函式啟動延遲的工作佇列，該佇列跟蹤 PHY 的狀態。如果您想維護自己的狀態機，請勿呼叫此函式。

void phy_error(struct phy_device *phydev)¶: 為此 PHY 裝置進入 ERROR 狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

響應於讀取或寫入錯誤，將 PHY 移動到 ERROR 狀態，並告訴控制器鏈路已斷開。必須在持有 phydev->lock 的情況下呼叫。

void phy_request_interrupt(struct phy_device *phydev)¶: 請求並啟用 PHY 裝置的 interrupts

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

請求並啟用給定 PHY 的 interrupts。: 如果失敗，則我們將 irq 設定為 PHY_POLL。僅應使用有效的 IRQ 號呼叫此方法。

void phy_free_interrupt(struct phy_device *phydev)¶: 停用並釋放 PHY 裝置的 interrupts

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

停用並釋放給定 PHY 的 interrupts。: 僅應使用有效的 IRQ 號呼叫此方法。

void phy_stop(struct phy_device *phydev)¶: 斷開 PHY 鏈路，並停止檢查狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

void phy_start(struct phy_device *phydev)¶: 啟動或重新啟動 PHY 裝置

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

指示附加裝置已準備好: 處理與 PHY 相關的工作。啟動期間用於啟動 PHY，在呼叫 phy_stop() 後用於恢復操作。還用於指示 MDIO 匯流排已清除錯誤情況。

void phy_mac_interrupt(struct phy_device *phydev)¶: MAC 表示鏈路已更改

引數

struct phy_device *phydev: 具有更改鏈路的 phy_device 結構

描述

MAC 層能夠指示 PHY 鏈路狀態已發生更改。觸發狀態機並處理工作佇列。

int phy_loopback(struct phy_device *phydev, bool enable, int speed)¶: 配置 PHY 的環回模式

引數

struct phy_device *phydev: 目標 phy_device 結構
bool enable: 啟用或停用環回模式
int speed: 使用速度啟用環回模式

描述

配置 PHY 的環回模式，並在速度更改時發出鏈路斷開和鏈路連線訊號。

返回 skb dst_entry

成功時返回 0，失敗時返回負錯誤程式碼。

int phy_eee_tx_clock_stop_capable(struct phy_device *phydev)¶: 指示 MAC 是否可以停止 tx 時鐘

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

指示 MAC 是否可以在 LPI 狀態下停用傳輸 xMII 時鐘。如果 MAC 可以停止傳輸時鐘，則返回 1，如果 MAC 必須不停止傳輸時鐘，則返回 0，或返回負錯誤。

int phy_eee_rx_clock_stop(struct phy_device *phydev, bool clk_stop_enable)¶: 在 LPI 中配置 PHY 接收時鐘

引數

struct phy_device *phydev: 目標 phy_device 結構
bool clk_stop_enable: 標誌，指示是否可以停止時鐘

描述

配置 PHY 是否可以在 LPI 模式下停用其接收時鐘。請參見 IEEE 802.3 Sections 22.2.2.2、35.2.2.10 和 45.2.3.1.4。

返回 skb dst_entry

0 或負錯誤。

int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable)¶: 初始化並檢查 EEE 功能

引數

struct phy_device *phydev: 目標 phy_device 結構
bool clk_stop_enable: PHY 可以在 LPI 期間停止時鐘

描述

它透過檢視 MMD 暫存器 3.20 和 7.60/61 來檢查是否支援節能乙太網 (EEE)，並且如果需要，它會透過設定 “Clock stop enable” 位來程式設計 MMD 暫存器 3.0。

int phy_get_eee_err(struct phy_device *phydev)¶: 報告EEE喚醒錯誤計數

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

用於報告PHY未能完成其正常喚醒序列的次數。

int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)¶: 獲取EEE支援和狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_keee *data: ethtool_keee 資料

描述

獲取當前的EEE設定，填充 **data** 的所有成員。

int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)¶: 設定EEE支援和狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_keee *data: ethtool_keee 資料

描述

用於程式設計Advertisement EEE暫存器。

int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)¶: 配置網路喚醒

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_wolinfo *wol: 請求的配置

void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol)¶: 獲取當前網路喚醒配置

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_wolinfo *wol: 將當前配置儲存在此處

int phy_ethtool_nway_reset(struct net_device *ndev)¶: 重新啟動自動協商

引數

struct net_device *ndev: 要重新啟動自動協商的網路裝置

int phy_config_interrupt(struct phy_device *phydev, bool interrupts)¶: 為請求的中斷配置PHY裝置

引數

struct phy_device *phydev: phy_device 結構
bool interrupts: 要為此 **phydev** 配置的中斷標誌

描述

成功時返回0，出錯時返回 < 0。

unsigned int phy_supported_speeds(struct phy_device *phy, unsigned int *speeds, unsigned int size)¶: 返回PHY裝置當前支援的所有速度

引數

struct phy_device *phy: 要返回支援速度的PHY裝置。
unsigned int *speeds: 用於儲存支援速度的緩衝區。
unsigned int size: speeds緩衝區的大小。

描述

返回支援的速度數，並使用支援的速度填充speeds緩衝區。如果speeds緩衝區太小而無法容納所有當前支援的速度，將返回儘可能多的速度。

void phy_sanitize_settings(struct phy_device *phydev)¶: 確保將PHY設定為支援的速度和雙工

引數

struct phy_device *phydev: 目標phy_device結構

描述

確保將PHY設定為支援的速度和: 雙工。按此順序降一級：1000/FULL、1000/HALF、100/FULL、100/HALF、10/FULL、10/HALF。

int __phy_hwtstamp_get(struct phy_device *phydev, struct kernel_hwtstamp_config *config)¶: 從PHY獲取硬體時間戳配置

引數

struct phy_device *phydev: PHY裝置結構
struct kernel_hwtstamp_config *config: 儲存時間戳配置的結構

描述

查詢PHY裝置以獲取其當前的硬體時間戳配置。

int __phy_hwtstamp_set(struct phy_device *phydev, struct kernel_hwtstamp_config *config, struct netlink_ext_ack *extack)¶: 修改PHY硬體時間戳配置

引數

struct phy_device *phydev: PHY裝置結構
struct kernel_hwtstamp_config *config: 儲存時間戳配置的結構
struct netlink_ext_ack *extack: netlink擴充套件確認結構，用於錯誤報告

void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies)¶: 觸發狀態機立即執行

引數

struct phy_device *phydev: phy_device 結構
unsigned long jiffies: 在這些jiffies之後執行狀態機

void __phy_ethtool_get_phy_stats(struct phy_device *phydev, struct ethtool_eth_phy_stats *phy_stats, struct ethtool_phy_stats *phydev_stats)¶: 檢索標準化的PHY統計資訊

引數

struct phy_device *phydev: 指向PHY裝置的指標
struct ethtool_eth_phy_stats *phy_stats: 指向ethtool_eth_phy_stats結構的指標
struct ethtool_phy_stats *phydev_stats: 指向ethtool_phy_stats結構的指標

描述

使用核心定義的介面獲取PHY統計資訊，以實現一致的診斷。與phy_ethtool_get_stats()不同，後者允許自定義統計資訊，此函式強制使用標準化格式，以實現更好的互操作性。

void __phy_ethtool_get_link_ext_stats(struct phy_device *phydev, struct ethtool_link_ext_stats *link_stats)¶: 檢索PHY的擴充套件鏈路統計資訊

引數

struct phy_device *phydev: 指向PHY裝置的指標
struct ethtool_link_ext_stats *link_stats: 指向用於儲存擴充套件鏈路統計資訊的結構的指標

描述

使用鏈路斷開事件計數和其他特定於驅動程式的鏈路統計資訊（如果可用）填充ethtool_link_ext_stats結構。

int phy_ethtool_get_plca_cfg(struct phy_device *phydev, struct phy_plca_cfg *plca_cfg)¶: 獲取PLCA RS配置

引數

struct phy_device *phydev: phy_device 結構
struct phy_plca_cfg *plca_cfg: 儲存檢索的配置的位置

描述

從PHY檢索PLCA配置。成功時返回0，如果發生錯誤，則返回負值。

int plca_check_valid(struct phy_device *phydev, const struct phy_plca_cfg *plca_cfg, struct netlink_ext_ack *extack)¶: 啟用前檢查PLCA配置

引數

struct phy_device *phydev: phy_device 結構
const struct phy_plca_cfg *plca_cfg: 當前PLCA配置
struct netlink_ext_ack *extack: 用於報告有用錯誤訊息的 extack

描述

檢查PLCA和PHY配置是否一致，並且啟用PLCA是否安全。成功時返回0，如果PLCA或PHY配置不一致，則返回負值。

int phy_ethtool_set_plca_cfg(struct phy_device *phydev, const struct phy_plca_cfg *plca_cfg, struct netlink_ext_ack *extack)¶: 設定PLCA RS配置

引數

struct phy_device *phydev: phy_device 結構
const struct phy_plca_cfg *plca_cfg: 要應用的新PLCA配置
struct netlink_ext_ack *extack: 用於報告有用錯誤訊息的 extack

描述

在PHY中設定PLCA配置。成功時返回0，如果發生錯誤，則返回負值。

int phy_ethtool_get_plca_status(struct phy_device *phydev, struct phy_plca_status *plca_st)¶: 獲取PLCA RS狀態資訊

引數

struct phy_device *phydev: phy_device 結構
struct phy_plca_status *plca_st: 儲存檢索的狀態資訊的位置

描述

從PHY檢索PLCA狀態資訊。成功時返回0，如果發生錯誤，則返回負值。

int phy_check_link_status(struct phy_device *phydev)¶: 檢查鏈路狀態並相應地設定狀態

引數

struct phy_device *phydev: phy_device 結構

描述

檢查鏈路以及是否已觸發/正在執行自動協商，並相應地設定狀態

void phy_stop_machine(struct phy_device *phydev)¶: 停止PHY狀態機跟蹤

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

停止狀態機延遲工作佇列，將: 狀態設定為UP（除非尚未啟動）。必須在phy_detach之前呼叫此函式。

int phy_disable_interrupts(struct phy_device *phydev)¶: 從PHY側停用PHY中斷

引數

struct phy_device *phydev: 目標 phy_device 結構

irqreturn_t phy_interrupt(int irq, void *phy_dat)¶: PHY中斷處理程式

引數

int irq: 中斷線
void *phy_dat: phy_device 指標

描述

處理PHY中斷

int phy_enable_interrupts(struct phy_device *phydev)¶: 從PHY側啟用中斷

引數

struct phy_device *phydev: 目標 phy_device 結構

int phy_update_stats(struct phy_device *phydev)¶: 如果支援，則更新PHY裝置統計資訊。

引數

struct phy_device *phydev: 指向PHY裝置結構的指標。

描述

如果PHY驅動程式提供了update_stats回撥，則此函式會呼叫它來更新PHY統計資訊。如果不是，則返回0。

返回 skb dst_entry

成功時返回0，如果回撥失敗，則返回負錯誤程式碼。

unsigned int phy_get_next_update_time(struct phy_device *phydev)¶: 確定下一個PHY更新時間

引數

struct phy_device *phydev: 指向phy_device結構的指標

描述

此函式查詢PHY驅動程式以獲取下一次輪詢事件的時間。如果驅動程式未實現回撥，則使用預設值。

返回 skb dst_entry

下一次輪詢事件的時間（以jiffies為單位）

void phy_state_machine(struct work_struct *work)¶: 處理狀態機

引數

struct work_struct *work: 描述要完成的工作的work_struct

void phy_ethtool_set_eee_noneg(struct phy_device *phydev, const struct eee_config *old_cfg)¶: 在不進行PHY重新協商的情況下調整MAC LPI配置

引數

struct phy_device *phydev: 指向目標PHY裝置結構的指標
const struct eee_config *old_cfg: 指向包含舊EEE設定的eee_config結構的指標

描述

此函式更新能源效率乙太網（EEE）配置，適用於僅MAC的低功耗空閒（LPI）配置更改，而不觸發PHY重新協商的情況。它透過迴圈鏈路關閉和啟動來確保MAC正確瞭解新的LPI設定，這對於MAC採用新配置是必要的。只有在tx_lpi_enabled或tx_lpi_timer配置發生更改時，才會進行此調整。

const char *phy_speed_to_str(int speed)¶: 返回表示PHY鏈路速度的字串

引數

int speed: 鏈路速度

const char *phy_duplex_to_str(unsigned int duplex)¶: 返回描述雙工的字串

引數

unsigned int duplex: 要描述的雙工設定

const char *phy_rate_matching_to_str(int rate_matching)¶: 返回描述速率匹配的字串

引數

int rate_matching: 要描述的速率匹配型別

int phy_interface_num_ports(phy_interface_t interface)¶: 返回給定的MAC-PHY物理鏈路可以承載的鏈路數。如果未知，則返回0；否則返回鏈路數。

引數

phy_interface_t interface: 我們要獲取埠數的介面模式

void phy_set_max_speed(struct phy_device *phydev, u32 max_speed)¶: 設定PHY應支援的最大速度

引數

struct phy_device *phydev: phy_device 結構
u32 max_speed: 最大速度

描述

PHY可能比MAC更強大。例如，快速乙太網連線到1G PHY。此函式允許MAC指示其最大速度，從而限制PHY將通告的內容。

void phy_resolve_aneg_pause(struct phy_device *phydev)¶: 確定暫停自動協商結果

引數

struct phy_device *phydev: phy_device 結構

描述

完成自動協商後，可以解析本地暫停設定。確定MAC是否應使用暫停和非對稱暫停。

void phy_resolve_aneg_linkmode(struct phy_device *phydev)¶: 將通告解析為PHY設定

引數

struct phy_device *phydev: phy_device 結構

描述

將我們和鏈路合作伙伴的通告解析為其相應的速度和雙工。如果協商了全雙工，請從鏈路合作伙伴掩碼中提取暫停模式。

int __phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)¶: 用於從給定PHY上的MMD讀取暫存器的便捷函式。

引數

struct phy_device *phydev: phy_device 結構
int devad: 要從中讀取的MMD（0..31）
u32 regnum: 要讀取的MMD上的暫存器（0..65535）

描述

與__phy_read()相同的規則；

int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)¶: 用於從給定PHY上的MMD讀取暫存器的便捷函式。

引數

struct phy_device *phydev: phy_device 結構
int devad: 要從中讀取的MMD
u32 regnum: 要讀取的MMD上的暫存器

描述

與phy_read()相同的規則；

int __phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 用於在給定PHY上的MMD上寫入暫存器的便捷函式。

引數

struct phy_device *phydev: phy_device 結構
int devad: 要從中讀取的MMD
u32 regnum: 要讀取的MMD上的暫存器
u16 val: 要寫入 **regnum** 的值

描述

與__phy_write()相同的規則；

int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 用於在給定PHY上的MMD上寫入暫存器的便捷函式。

引數

struct phy_device *phydev: phy_device 結構
int devad: 要從中讀取的MMD
u32 regnum: 要讀取的MMD上的暫存器
u16 val: 要寫入 **regnum** 的值

描述

與 phy_write() 相同的規則；

int __phy_package_read_mmd(struct phy_device *phydev, unsigned int addr_offset, int devad, u32 regnum)¶: 讀取相對於 PHY 封裝基址的 MMD 暫存器

引數

struct phy_device *phydev: phy_device 結構
unsigned int addr_offset: 要新增到 PHY 封裝 base_addr 的偏移量
int devad: 要從中讀取的MMD
u32 regnum: 要讀取的MMD上的暫存器

描述

方便的輔助函式，用於使用 PHY 封裝基址讀取給定 PHY 上 MMD 的暫存器。基地址會被新增到 addr_offset 值。

與 __phy_read() 相同的呼叫規則；

注意

假設整個 PHY 封裝是 C22 或 C45。

int __phy_package_write_mmd(struct phy_device *phydev, unsigned int addr_offset, int devad, u32 regnum, u16 val)¶: 寫入相對於 PHY 封裝基址的 MMD 暫存器

引數

struct phy_device *phydev: phy_device 結構
unsigned int addr_offset: 要新增到 PHY 封裝 base_addr 的偏移量
int devad: 要寫入的 MMD
u32 regnum: 要寫入的 MMD 上的暫存器
u16 val: 要寫入 **regnum** 的值

描述

方便的輔助函式，用於使用 PHY 封裝基址寫入給定 PHY 上 MMD 的暫存器。基地址會被新增到 addr_offset 值。

與 __phy_write() 相同的呼叫規則；

注意

假設整個 PHY 封裝是 C22 或 C45。

int phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)¶: 用於修改 PHY 暫存器的函式

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

描述

返回負 errno，如果沒有更改則返回 0，如果發生更改則返回 1

int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)¶: 用於修改 PHY 暫存器的便捷函式

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)¶: 用於修改給定 PHY 暫存器的便捷函式

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int __phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改 MMD 上的暫存器的函式

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

描述

未鎖定的輔助函式，允許修改 MMD 暫存器，新暫存器值 = (舊暫存器值 & ~mask) | set

返回負 errno，如果沒有更改則返回 0，如果發生更改則返回 1

int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改 MMD 上的暫存器的函式

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

描述

返回負 errno，如果沒有更改則返回 0，如果發生更改則返回 1

int __phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改 MMD 上的暫存器的便捷函式

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改 MMD 上的暫存器的便捷函式

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 在掩碼中設定的位的新值，用於寫入 regnum

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int phy_save_page(struct phy_device *phydev)¶: 獲取匯流排鎖並儲存當前頁面

引數

struct phy_device *phydev: 指向 struct phy_device 的指標

描述

獲取 MDIO 匯流排鎖，並返回當前頁碼。如果出錯，則返回負 errno。phy_restore_page() 必須在此函式之後始終被呼叫，無論呼叫成功與否。

int phy_select_page(struct phy_device *phydev, int page)¶: 獲取匯流排鎖，儲存當前頁面，並設定頁面

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int page: 所需的頁面

描述

獲取 MDIO 匯流排鎖以防止併發訪問，儲存當前的 PHY 頁面，並設定當前頁面。如果出錯，則返回負 errno，否則返回上一頁的頁碼。phy_restore_page() 必須在此函式之後始終被呼叫，無論呼叫成功與否。

int phy_restore_page(struct phy_device *phydev, int oldpage, int ret)¶: 恢復頁面暫存器並釋放匯流排鎖

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int oldpage: 舊頁面，phy_save_page() 或 phy_select_page() 的返回值
int ret: 操作的返回碼

描述

釋放 MDIO 匯流排鎖，如果 oldpage 是有效的頁面，則恢復該頁面。此函式會傳遞操作組中最早的錯誤程式碼。

返回 skb dst_entry

如果 oldpage 是負值，則為 oldpage，否則，如果 ret 是負 errno 值，則為 ret，否則，如果 phy_write_page() 出錯，則為 phy_write_page() 的負值，否則為 ret。

int phy_read_paged(struct phy_device *phydev, int page, u32 regnum)¶: 用於讀取分頁暫存器的便捷函式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int page: phy 的頁面
u32 regnum: 暫存器號

描述

與 phy_read() 相同的規則。

int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val)¶: 用於寫入分頁暫存器的便捷函式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int page: phy 的頁面
u32 regnum: 暫存器號
u16 val: 要寫入的值

描述

與 phy_write() 相同的規則。

int phy_modify_paged_changed(struct phy_device *phydev, int page, u32 regnum, u16 mask, u16 set)¶: 用於修改分頁暫存器的函式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int page: phy 的頁面
u32 regnum: 暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

描述

返回負 errno，如果沒有更改則返回 0，如果發生更改則返回 1

int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum, u16 mask, u16 set)¶: 用於修改分頁暫存器的便捷函式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
int page: phy 的頁面
u32 regnum: 暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

描述

與 phy_read() 和 phy_write() 相同的規則。

int genphy_c45_pma_resume(struct phy_device *phydev)¶: 喚醒 PMA 模組

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_pma_suspend(struct phy_device *phydev)¶: 掛起 PMA 模組

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_pma_baset1_setup_master_slave(struct phy_device *phydev)¶: 配置 BaseT1 裝置的強制主/從角色。

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_pma_setup_forced(struct phy_device *phydev)¶: 配置強制速度

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_an_config_aneg(struct phy_device *phydev)¶: 配置通告暫存器

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

基於 phydev->advertising 中設定的模式配置通告暫存器

如果失敗，則返回負 errno 程式碼；如果通告未更改，則返回 0；如果通告的模式已更改，則返回 1。

int genphy_c45_an_disable_aneg(struct phy_device *phydev)¶: 停用自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

在 Clause 45 PHY 中停用自動協商。鏈路引數透過 PMA/PMD MMD 暫存器進行控制。

成功時返回零，失敗時返回負 errno 程式碼。

int genphy_c45_restart_aneg(struct phy_device *phydev)¶: 啟用並重新啟動自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

這假定存在自動協商 MMD。

啟用並重新啟動自動協商。

int genphy_c45_check_and_restart_aneg(struct phy_device *phydev, bool restart)¶: 啟用並重新啟動自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構
bool restart: 是否請求 aneg 重啟

描述

這假定存在自動協商 MMD。

檢查，並在需要時重新啟動自動協商。

int genphy_c45_aneg_done(struct phy_device *phydev)¶: 返回自動協商完成狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

這假定存在自動協商 MMD。

從自動協商 MMD 讀取狀態暫存器，返回：- 如果自動協商已完成，則返回正數 - 如果出錯，則返回負 errno 程式碼 - 否則返回零

int genphy_c45_read_link(struct phy_device *phydev)¶: 從 MMD 讀取總體鏈路狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從指定的 MMD 讀取鏈路狀態，如果它們都指示鏈路已啟動，則將 phydev->link 設定為 1。如果遇到錯誤，將返回負 errno，否則返回零。

int genphy_c45_read_lpa(struct phy_device *phydev)¶: 讀取鏈路夥伴通告和暫停

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

讀取 Clause 45 定義的基礎 (7.19) 和 10G (7.33) 狀態暫存器，填寫鏈路夥伴通告、暫停和 phydev 中的 asym_pause 成員。這假定存在自動協商 MMD，並且底板位 (7.48.0) 已清除。 Clause 45 PHY 驅動程式應從供應商暫存器中填寫鏈路夥伴通告的其餘部分。

int genphy_c45_pma_baset1_read_master_slave(struct phy_device *phydev)¶: 讀取強制主/從配置

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_read_pma(struct phy_device *phydev)¶: 從 PMA 讀取鏈路速度等

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_read_mdix(struct phy_device *phydev)¶: 從 PMA 讀取 mdix 狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_read_eee_abilities(struct phy_device *phydev)¶: 讀取支援的 EEE 鏈路模式

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_an_config_eee_aneg(struct phy_device *phydev)¶: 配置 EEE 通告

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_c45_pma_baset1_read_abilities(struct phy_device *phydev)¶: 從 PMA 讀取支援的 baset1 鏈路模式

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從擴充套件的 BASE-T1 能力暫存器讀取支援的鏈路模式

int genphy_c45_pma_read_ext_abilities(struct phy_device *phydev)¶: 從 PMA 讀取支援的鏈路模式

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從 PMA/PMD 擴充套件能力暫存器（暫存器 1.11）讀取支援的鏈路模式。

int genphy_c45_pma_read_abilities(struct phy_device *phydev)¶: 從 PMA 讀取支援的鏈路模式

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從 PMA 狀態 2 (1.8) 暫存器讀取支援的鏈路模式。如果設定了位 1.8.9，則使用 PMA 擴充套件能力 (1.11) 暫存器中的值構建支援的模式列表，指示 1000BASET 和 10G 相關模式。如果設定了位 1.11.14，則該列表也會使用 2.5G/5G PMA 擴充套件暫存器 (1.21) 中的模式進行擴充套件，指示是否支援 2.5GBASET 和 5GBASET。

int genphy_c45_read_status(struct phy_device *phydev)¶: 讀取 PHY 狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

從 PHY 讀取狀態並相應地設定 phy_device 成員。

int genphy_c45_config_aneg(struct phy_device *phydev)¶: 重新啟動自動協商或強制設定

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

如果啟用了自動協商，我們配置: 通告，然後重新啟動自動協商。如果未啟用，則強制配置。

int genphy_c45_fast_retrain(struct phy_device *phydev, bool enable)¶: 配置快速重訓暫存器

引數

struct phy_device *phydev: 目標 phy_device 結構
bool enable: 是否啟用快速重訓

描述

如果啟用了快速重訓，我們會將 PHY 配置為: 通告快速重訓練能力和 THP Bypass 請求，然後啟用快速重訓練。如果未啟用，則配置為停用快速重訓練。

int genphy_c45_plca_get_cfg(struct phy_device *phydev, struct phy_plca_cfg *plca_cfg)¶: 從標準暫存器獲取 PLCA 配置

引數

struct phy_device *phydev: 目標 phy_device 結構
struct phy_plca_cfg *plca_cfg: 用於儲存 PLCA 配置的輸出結構

描述

如果 PHY 符合開放聯盟 TC14 10BASE-T1S PLCA: 管理暫存器規範，此函式可用於從 MMD 31 中的標準暫存器檢索當前 PLCA 配置。

int genphy_c45_plca_set_cfg(struct phy_device *phydev, const struct phy_plca_cfg *plca_cfg)¶: 使用標準暫存器設定 PLCA 配置

引數

struct phy_device *phydev: 目標 phy_device 結構
const struct phy_plca_cfg *plca_cfg: 包含 PLCA 配置的結構。設定為 -1 的欄位不會更改。

描述

如果 PHY 符合開放聯盟 TC14 10BASE-T1S PLCA: 管理暫存器規範，此函式可用於使用 MMD 31 中的標準暫存器修改 PLCA 配置。

int genphy_c45_plca_get_status(struct phy_device *phydev, struct phy_plca_status *plca_st)¶: 從標準暫存器獲取 PLCA 狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
struct phy_plca_status *plca_st: 用於儲存 PLCA 狀態的輸出結構

描述

如果 PHY 符合開放聯盟 TC14 10BASE-T1S PLCA: 管理暫存器規範，此函式可用於從 MMD 31 中的標準暫存器檢索當前 PLCA 狀態資訊。

int genphy_c45_eee_is_active(struct phy_device *phydev, unsigned long *lp)¶: 獲取 EEE 狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
unsigned long *lp: 用於儲存 LP 通告的鏈路模式的變數

描述

此函式將讀取鏈路夥伴 PHY 通告，並將其與本地通告進行比較以返回當前的 EEE 狀態。

int genphy_c45_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)¶: 獲取EEE支援和狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_keee *data: ethtool_keee 資料

描述

它報告支援/通告/LP 通告能力。

int genphy_c45_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)¶: 設定EEE支援和狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
struct ethtool_keee *data: ethtool_keee 資料

描述

設定支援/通告/LP 通告能力。如果 eee_enabled 為 false，則不通告任何鏈路模式，但保留先前通告的鏈路模式。這允許以非破壞性方式啟用/停用 EEE。如果未更改，則返回錯誤程式碼 0，如果更改觸發了自動協商，則返回正值。

enum phy_interface_t¶: 介面模式定義

常量

PHY_INTERFACE_MODE_NA: 不適用 - 請勿觸控
PHY_INTERFACE_MODE_INTERNAL: 無介面，MAC 和 PHY 組合
PHY_INTERFACE_MODE_MII: 介質無關介面
PHY_INTERFACE_MODE_GMII: 千兆介質無關介面
PHY_INTERFACE_MODE_SGMII: 序列千兆介質無關介面
PHY_INTERFACE_MODE_TBI: 十位介面
PHY_INTERFACE_MODE_REVMII: 反向介質無關介面
PHY_INTERFACE_MODE_RMII: 精簡介質無關介面
PHY_INTERFACE_MODE_REVRMII: PHY 角色中的精簡介質無關介面
PHY_INTERFACE_MODE_RGMII: 精簡千兆介質無關介面
PHY_INTERFACE_MODE_RGMII_ID: 具有內部 RX+TX 延遲的 RGMII
PHY_INTERFACE_MODE_RGMII_RXID: 具有內部 RX 延遲的 RGMII
PHY_INTERFACE_MODE_RGMII_TXID: 具有內部 TX 延遲的 RGMII
PHY_INTERFACE_MODE_RTBI: 精簡 TBI
PHY_INTERFACE_MODE_SMII: 序列 MII
PHY_INTERFACE_MODE_XGMII: 10 千兆介質無關介面
PHY_INTERFACE_MODE_XLGMII: 40 千兆介質無關介面
PHY_INTERFACE_MODE_MOCA: 同軸多媒體
PHY_INTERFACE_MODE_PSGMII: 五路 SGMII
PHY_INTERFACE_MODE_QSGMII: 四路 SGMII
PHY_INTERFACE_MODE_TRGMII: Turbo RGMII
PHY_INTERFACE_MODE_100BASEX: 100 BaseX
PHY_INTERFACE_MODE_1000BASEX: 1000 BaseX
PHY_INTERFACE_MODE_2500BASEX: 2500 BaseX
PHY_INTERFACE_MODE_5GBASER: 5G BaseR
PHY_INTERFACE_MODE_RXAUI: 精簡 XAUI
PHY_INTERFACE_MODE_XAUI: 10 千兆附件單元介面
PHY_INTERFACE_MODE_10GBASER: 10G BaseR
PHY_INTERFACE_MODE_25GBASER: 25G BaseR
PHY_INTERFACE_MODE_USXGMII: 通用序列 10GE MII
PHY_INTERFACE_MODE_10GKR: 10GBASE-KR - 帶有 Clause 73 AN
PHY_INTERFACE_MODE_QUSGMII: 四路通用 SGMII
PHY_INTERFACE_MODE_1000BASEKX: 1000Base-KX - 帶有 Clause 73 AN
PHY_INTERFACE_MODE_10G_QXGMII: 10G-QXGMII - 4 個埠透過 10G USXGMII
PHY_INTERFACE_MODE_MAX: 簿記

描述

描述 MAC 和 PHY 之間的介面。

const char *phy_modes(phy_interface_t interface)¶: 將 phy_interface_t 列舉對映到 phy-mode 的裝置樹繫結

引數

phy_interface_t interface: enum phy_interface_t 值

描述

將此檔案中定義的列舉 phy_interface_t 對映到 ‘phy-mode’ 的裝置樹繫結，以便乙太網裝置驅動程式可以從裝置樹獲取 PHY 介面。

long rgmii_clock(int speed)¶: 將鏈路速度對映到時鐘頻率

引數

int speed: 鏈路速度值

描述

將 RGMII 支援的鏈路速度對映到時鐘頻率。

返回 skb dst_entry

時鐘頻率或負 errno

struct mdio_bus_stats¶: MDIO 匯流排的統計計數器

定義:

struct mdio_bus_stats {
    u64_stats_t transfers;
    u64_stats_t errors;
    u64_stats_t writes;
    u64_stats_t reads;
    struct u64_stats_sync syncp;
};

成員

傳輸: 傳輸總數，即寫入 + 讀取
錯誤: 返回錯誤的 MDIO 傳輸數
寫入: 寫入傳輸數
讀取: 讀取傳輸數
syncp: 用於遞增統計資訊的同步

struct mii_bus¶: 表示 MDIO 匯流排

定義:

struct mii_bus {
    struct module *owner;
    const char *name;
    char id[MII_BUS_ID_SIZE];
    void *priv;
    int (*read)(struct mii_bus *bus, int addr, int regnum);
    int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
    int (*read_c45)(struct mii_bus *bus, int addr, int devnum, int regnum);
    int (*write_c45)(struct mii_bus *bus, int addr, int devnum, int regnum, u16 val);
    int (*reset)(struct mii_bus *bus);
    struct mdio_bus_stats stats[PHY_MAX_ADDR];
    struct mutex mdio_lock;
    struct device *parent;
    enum {
        MDIOBUS_ALLOCATED = 1,
        MDIOBUS_REGISTERED,
        MDIOBUS_UNREGISTERED,
        MDIOBUS_RELEASED,
    } state;
    struct device dev;
    struct mdio_device *mdio_map[PHY_MAX_ADDR];
    u32 phy_mask;
    u32 phy_ignore_ta_mask;
    int irq[PHY_MAX_ADDR];
    int reset_delay_us;
    int reset_post_delay_us;
    struct gpio_desc *reset_gpiod;
    struct mutex shared_lock;
    struct phy_package_shared *shared[PHY_MAX_ADDR];
};

成員

所有者: 誰擁有此裝置
name: 此 MDIO 裝置的友好名稱，或驅動程式名稱
id: 此匯流排的唯一識別符號，通常來自匯流排層次結構
FIXME：清理 struct net_device，以便網路協議資訊移出。: 驅動程式私有資料
讀取: 在總線上執行讀取傳輸
寫入: 在總線上執行寫入傳輸
read_c45: 在總線上執行 C45 讀取傳輸
write_c45: 在總線上執行 C45 寫入傳輸
重置: 執行匯流排重置
裝置所屬的組: 總線上每個裝置的統計計數器
mdio_lock: 用於確保一次只有一個事物可以讀取/寫入 MDIO 匯流排的鎖
父節點: 此匯流排的父裝置
狀態: 匯流排結構的狀態
dev: 核心裝置表示
mdio_map: 總線上所有 MDIO 裝置的列表
phy_mask: 探測時要忽略的 PHY 地址
phy_ignore_ta_mask: 忽略 TA/讀取失敗的 PHY 地址
用於區分共享相同功能的裝置: 中斷陣列，每個 PHY 的中斷都在與其地址匹配的索引處
reset_delay_us: GPIO 重置脈衝寬度（以微秒為單位）
reset_post_delay_us: GPIO 重置取消斷言延遲（以微秒為單位）
reset_gpiod: 重置 GPIO 描述符指標
shared_lock: 保護對共享元素的訪問
shared: 不同 PHY 之間的共享狀態

描述

PHY 的匯流排類。提供對 PHY 的訪問的裝置應使用此結構註冊

struct mii_bus *mdiobus_alloc(void)¶: 分配 MDIO 匯流排結構

引數

void: 無引數

描述

MDIO 匯流排的內部狀態將設定為 MDIOBUS_ALLOCATED，準備好供驅動程式註冊匯流排。

enum phy_state¶: PHY 狀態機狀態

常量

PHY_DOWN: PHY 裝置和驅動程式尚未準備好執行任何操作。如果且僅當 PHY 處於此狀態時才應呼叫探測，因為 PHY 裝置存在。- PHY 驅動程式探測函式會將狀態設定為 PHY_READY
PHY_READY: PHY 已準備好傳送和接收資料包，但控制器尚未準備好。預設情況下，不實現探測的 PHY 將由 phy_probe() 設定為此狀態。- 啟動會將狀態設定為 UP
PHY_HALTED: PHY 已啟動，但不執行輪詢或中斷。- phy_start 移動到 PHY_UP
PHY_ERROR: PHY 已啟動，但處於錯誤狀態。- phy_stop 移動到 PHY_HALTED
PHY_UP: PHY 和連線的裝置已準備好工作。中斷應在此處啟動。- 計時器移動到 PHY_NOLINK 或 PHY_RUNNING
PHY_RUNNING: PHY 當前已啟動、正在執行，並且可能正在傳送和/或接收資料包 - 如果鏈路斷開，則 irq 或計時器將設定 PHY_NOLINK - phy_stop 移動到 PHY_HALTED
PHY_NOLINK: PHY 已啟動，但當前未插入。- 如果鏈路恢復，則 irq 或計時器將設定 PHY_RUNNING - phy_stop 移動到 PHY_HALTED
PHY_CABLETEST: PHY 正在執行電纜測試。不希望資料包接收/傳送工作，載波將指示為斷開。PHY 將每秒輪詢一次，或中斷以瞭解其當前狀態。完成後，移動到 UP 以重新啟動 PHY。- phy_stop 中止正在執行的測試並移動到 PHY_HALTED

struct phy_c45_device_ids¶: 802.3-c45 裝置識別符號

定義:

struct phy_c45_device_ids {
    u32 devices_in_package;
    u32 mmds_present;
    u32 device_ids[MDIO_MMD_NUM];
};

成員

devices_in_package: 包暫存器值中的 IEEE 802.3 裝置。
mmds_present: MMD 的位向量存在。
device_ids: 每個現有裝置的裝置識別符號。

struct phy_device¶: PHY 的例項

定義:

struct phy_device {
    struct mdio_device mdio;
    const struct phy_driver *drv;
    struct device_link *devlink;
    u32 phyindex;
    u32 phy_id;
    struct phy_c45_device_ids c45_ids;
    unsigned is_c45:1;
    unsigned is_internal:1;
    unsigned is_pseudo_fixed_link:1;
    unsigned is_gigabit_capable:1;
    unsigned has_fixups:1;
    unsigned suspended:1;
    unsigned suspended_by_mdio_bus:1;
    unsigned sysfs_links:1;
    unsigned loopback_enabled:1;
    unsigned downshifted_rate:1;
    unsigned is_on_sfp_module:1;
    unsigned mac_managed_pm:1;
    unsigned wol_enabled:1;
    unsigned autoneg:1;
    unsigned link:1;
    unsigned autoneg_complete:1;
    unsigned interrupts:1;
    unsigned irq_suspended:1;
    unsigned irq_rerun:1;
    unsigned default_timestamp:1;
    int rate_matching;
    enum phy_state state;
    u32 dev_flags;
    phy_interface_t interface;
    unsigned long possible_interfaces[BITS_TO_LONGS(PHY_INTERFACE_MODE_MAX)];
    int speed;
    int duplex;
    int port;
    int pause;
    int asym_pause;
    u8 master_slave_get;
    u8 master_slave_set;
    u8 master_slave_state;
    unsigned long supported[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long advertising[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long lp_advertising[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long adv_old[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long supported_eee[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long advertising_eee[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long eee_disabled_modes[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    bool enable_tx_lpi;
    bool eee_active;
    struct eee_config eee_cfg;
    unsigned long host_interfaces[BITS_TO_LONGS(PHY_INTERFACE_MODE_MAX)];
#ifdef CONFIG_LED_TRIGGER_PHY;
    struct phy_led_trigger *phy_led_triggers;
    unsigned int phy_num_led_triggers;
    struct phy_led_trigger *last_triggered;
    struct phy_led_trigger *led_link_trigger;
#endif;
    struct list_head leds;
    int irq;
    void *priv;
    struct phy_package_shared *shared;
    struct sk_buff *skb;
    void *ehdr;
    struct nlattr *nest;
    struct delayed_work state_queue;
    struct mutex lock;
    bool sfp_bus_attached;
    struct sfp_bus *sfp_bus;
    struct phylink *phylink;
    struct net_device *attached_dev;
    struct mii_timestamper *mii_ts;
    struct pse_control *psec;
    u8 mdix;
    u8 mdix_ctrl;
    int pma_extable;
    unsigned int link_down_events;
    void (*phy_link_change)(struct phy_device *phydev, bool up);
    void (*adjust_link)(struct net_device *dev);
#if IS_ENABLED(CONFIG_MACSEC);
    const struct macsec_ops *macsec_ops;
#endif;
};

成員

mdio

此 PHY 所在的 MDIO 匯流排

drv

指向此 PHY 例項的驅動程式的指標

devlink

如果當前 mac 介面使用的外部 phy 由另一個 mac 介面管理，則在 phy dev 和 mac dev 之間建立連結。

phyindex

跨 phy 的父樹的唯一 id，用於從使用者空間定址 PHY，類似於 ifindex。索引為零表示尚未為 PHY 分配 id。

phy_id

在發現期間找到的此裝置的 UID

c45_ids

如果 is_c45，則為 802.3-c45 裝置識別符號。

is_c45

如果此 PHY 使用子句 45 定址，則設定為 true。

is_internal

如果此 PHY 是 MAC 的內部 PHY，則設定為 true。

is_pseudo_fixed_link

如果此 PHY 是乙太網交換機等，則設定為 true。

is_gigabit_capable

如果 PHY 支援 1000Mbps，則設定為 true

has_fixups

如果此 PHY 具有修復程式/怪癖，則設定為 true。

suspended

如果此 PHY 已成功掛起，則設定為 true。

suspended_by_mdio_bus

如果此 PHY 已被 MDIO 匯流排掛起，則設定為 true。

sysfs_links

內部布林值跟蹤 sysfs 符號連結設定/刪除。

loopback_enabled

如果此 PHY 已成功環回，則設定為 true。

downshifted_rate

如果鏈路速度已降檔，則設定為 true。

is_on_sfp_module

如果 PHY 位於 SFP 模組上，則設定為 true。

mac_managed_pm

如果 MAC 驅動程式負責掛起/恢復 PHY，則設定為 true

wol_enabled

如果 PHY 或連線的 MAC 啟用了 Wake-on-LAN，則設定為 true。

autoneg

正在使用的標誌自動協商

link

當前鏈路狀態

autoneg_complete

鏈路自動協商已完成的標誌

interrupts

已啟用標誌中斷

irq_suspended

指示 PHY 已掛起的標誌，因此中斷處理應推遲到 PHY 恢復為止

irq_rerun

指示 PHY 掛起時發生中斷的標誌，需要在恢復後重新執行中斷處理程式

default_timestamp

指示我們是否使用 phy 時間戳作為預設時間戳的標誌

rate_matching

當前速率匹配模式

狀態

PHY 的管理狀態

dev_flags

PHY 驅動程式使用的特定於裝置的標誌。

位 [15:0] 可供 PHY 驅動程式用於傳達特定於驅動程式的行為。
位 [23:16] 目前保留供將來使用。
位 [31:24] 保留用於定義通用 PHY 驅動程式行為。

interface

enum phy_interface_t 值

possible_interfaces

如果連線的 PHY 將根據介質速度在介面模式之間切換，則為點陣圖。

speed

當前鏈路速度

duplex

當前雙工

port

當前埠

pause

當前暫停

asym_pause

當前非對稱暫停

master_slave_get

當前主/從通告

master_slave_set

使用者請求的主/從配置

master_slave_state

當前主/從配置

supported

組合 MAC/PHY 支援的鏈路模式

advertising

當前通告的鏈路模式

lp_advertising

當前鏈路夥伴通告的鏈路模式

adv_old

為 WoL 節電時儲存的通告

supported_eee

支援的 PHY EEE 鏈路模式

advertising_eee

當前通告的 EEE 鏈路模式

eee_disabled_modes

不通告的節能乙太網模式

enable_tx_lpi

為 True 時，MAC 應將 LPI 傳輸到 PHY

eee_active

phylib 私有狀態，指示已協商 EEE

eee_cfg

EEE 的使用者配置

host_interfaces

主機支援的 PHY 介面模式

phy_led_triggers

LED 觸發器陣列

phy_num_led_triggers

phy_led_triggers 中的觸發器數

last_triggered

鏈路速度的最後一個 LED 觸發器

led_link_trigger

鏈路啟動/關閉的 LED 觸發器

leds

PHY LED 結構列表

用於區分共享相同功能的裝置

PHY 中斷的 IRQ 號 (-1 如果沒有)

FIXME：清理 struct net_device，以便網路協議資訊移出。

指向驅動程式私有資料的指標

shared

指向一個包中 phy 共享的私有資料的指標

skb

用於電纜診斷的 Netlink 訊息

ehdr

用於電纜診斷的 nNtlink 標頭

nest

用於電纜診斷的 Netlink nest

state_queue

用於狀態機的工作佇列

請求核心在 lock 下執行所有 netdev_ops 和 ethtool_ops。

用於序列化訪問 PHY 的互斥鎖

sfp_bus_attached

指示 SFP 匯流排是否已連線的標誌

物理裝置可以自行附加以進行硬體時間戳

連線到此 PHY 光纖埠的 SFP 匯流排

phylink

指向此 PHY 的 phylink 例項的指標

attached_dev

連線的 enet 驅動程式的裝置例項 ptr

mii_ts

指向時間戳回撥的指標

psec

指向電源裝置控制結構的指標

mdix

當前交叉

mdix_ctrl

使用者交叉設定

pma_extable

PMA/PMD 擴充套件能力暫存器的快取值

link_down_events

鏈路丟失的次數

phy_link_change

用於 phylink 的回撥，用於通知鏈路更改

adjust_link

用於 enet 控制器響應更改的回撥：在鏈路狀態中。

當裝置移動到另一個網路名稱空間時，遵循此裝置的每個網路 netdev 通知程式塊的列表。

MACsec 解除安裝操作。

描述

中斷當前僅支援啟用或停用，但將來可能會更改為支援啟用和停用特定中斷

包含用於輪詢和中斷處理的一些基礎結構，以及處理 PHY 硬體狀態的轉變

struct phy_tdr_config¶: TDR 原始測試的配置

定義:

struct phy_tdr_config {
    u32 first;
    u32 last;
    u32 step;
    s8 pair;
};

成員

first: 第一個資料收集點的距離
last: 最後一個數據收集點的距離
step: 資料收集點之間的步長
pair: 要收集資料的電纜對的點陣圖

描述

一個結構，包含 TDR 電纜測試的可能配置引數。驅動程式不需要實現所有引數，但應報告實際使用的引數。所有距離都以釐米為單位。

enum link_inband_signalling¶: 支援的帶內信令模式

常量

LINK_INBAND_DISABLE: 可以停用帶內信令
LINK_INBAND_ENABLE: 可以在不繞過的情況下啟用帶內信令
LINK_INBAND_BYPASS: 可以在繞過的情況下啟用帶內信令

描述

僅當設定了有效位時，才能使用可能的和必需的位。如果可能位已清除，則表示無法使用帶內信令。僅當設定了可能位時，必需位才有效，並且表示必須使用帶內信令。

struct phy_plca_cfg¶: PLCA（物理層衝突避免）協調子層的配置。

定義:

struct phy_plca_cfg {
    int version;
    int enabled;
    int node_id;
    int node_cnt;
    int to_tmr;
    int burst_cnt;
    int burst_tmr;
};

成員

version: 只讀 PLCA 暫存器對映版本。-1 = 不可用。設定配置時忽略。格式與 PLCA IDVER 暫存器 (31.CA00) 報告的格式相同。-1 = 不可用。
enabled: PLCA 配置模式（啟用/停用）。-1 = 不可用/不設定。0 = 停用，任何其他值 = 啟用。
node_id: PLCA 本地節點識別符號。-1 = 不可用/不設定。允許的值 [0 .. 254]。255 = 節點已停用。
node_cnt: PLCA 節點計數（具有 TO 的最大節點數）。僅對協調器（node_id = 0）有意義。-1 = 不可用/不設定。允許的值 [1 .. 255]。
to_tmr: PLCA to_timer 的值（以位時間為單位），它確定 PLCA 傳輸機會視窗的開啟。有關更多詳細資訊，請參閱 IEEE802.3 Clause 148。to_timer 應在所有節點上設定為相等。-1 = 不可用/不設定。允許的值 [0 .. 255]。
burst_cnt: 控制允許節點在單個傳輸機會 (TO) 中傳送多少個附加幀。預設值 0 表示允許節點每個 TO 僅傳送一個幀。值 1 允許每個 TO 兩個幀，依此類推。-1 = 不可用/不設定。允許的值 [0 .. 255]。
burst_tmr: 控制在中斷突發之前等待 MAC 傳送新幀多少個位時間。此值應設定為大於 MAC 包間間隔的值（通常為 96 位）。-1 = 不可用/不設定。允許的值 [0 .. 255]。

描述

一個結構，包含用於設定/獲取 PLCA RS 配置的配置引數。驅動程式不需要實現所有引數，但應報告實際使用的引數。

struct phy_plca_status¶: PLCA（物理層衝突避免）協調子層的狀態。

定義:

struct phy_plca_status {
    bool pst;
};

成員

pst: PLCA 狀態，由 PLCA STATUS 暫存器 (31.CA03) 中的 PST 位報告，指示 BEACON 活動。

描述

一個結構，包含 PLCA RS 配置的狀態資訊。驅動程式不需要實現所有引數，但應報告實際使用的引數。

struct phy_led¶: 由 PHY 驅動的 LED

定義:

struct phy_led {
    struct list_head list;
    struct phy_device *phydev;
    struct led_classdev led_cdev;
    u8 index;
};

成員

list: LED 列表
物理鏈路拓撲跟蹤連線的 PHY: 此 LED 連線到的 PHY
led_cdev: 標準 LED 類結構
index: LED 的編號

struct phy_driver¶: 特定 PHY 型別的驅動程式結構

定義:

struct phy_driver {
    struct mdio_driver_common mdiodrv;
    u32 phy_id;
    char *name;
    u32 phy_id_mask;
    const unsigned long * const features;
    u32 flags;
    const void *driver_data;
    int (*soft_reset)(struct phy_device *phydev);
    int (*config_init)(struct phy_device *phydev);
    int (*probe)(struct phy_device *phydev);
    int (*get_features)(struct phy_device *phydev);
    unsigned int (*inband_caps)(struct phy_device *phydev, phy_interface_t interface);
    int (*config_inband)(struct phy_device *phydev, unsigned int modes);
    int (*get_rate_matching)(struct phy_device *phydev, phy_interface_t iface);
    int (*suspend)(struct phy_device *phydev);
    int (*resume)(struct phy_device *phydev);
    int (*config_aneg)(struct phy_device *phydev);
    int (*aneg_done)(struct phy_device *phydev);
    int (*read_status)(struct phy_device *phydev);
    int (*config_intr)(struct phy_device *phydev);
    irqreturn_t (*handle_interrupt)(struct phy_device *phydev);
    void (*remove)(struct phy_device *phydev);
    int (*match_phy_device)(struct phy_device *phydev, const struct phy_driver *phydrv);
    int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
    void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
    void (*link_change_notify)(struct phy_device *dev);
    int (*read_mmd)(struct phy_device *dev, int devnum, u16 regnum);
    int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum, u16 val);
    int (*read_page)(struct phy_device *dev);
    int (*write_page)(struct phy_device *dev, int page);
    int (*module_info)(struct phy_device *dev, struct ethtool_modinfo *modinfo);
    int (*module_eeprom)(struct phy_device *dev, struct ethtool_eeprom *ee, u8 *data);
    int (*cable_test_start)(struct phy_device *dev);
    int (*cable_test_tdr_start)(struct phy_device *dev, const struct phy_tdr_config *config);
    int (*cable_test_get_status)(struct phy_device *dev, bool *finished);
    void (*get_phy_stats)(struct phy_device *dev,struct ethtool_eth_phy_stats *eth_stats, struct ethtool_phy_stats *stats);
    void (*get_link_stats)(struct phy_device *dev, struct ethtool_link_ext_stats *link_stats);
    int (*update_stats)(struct phy_device *dev);
    int (*get_sset_count)(struct phy_device *dev);
    void (*get_strings)(struct phy_device *dev, u8 *data);
    void (*get_stats)(struct phy_device *dev, struct ethtool_stats *stats, u64 *data);
    int (*get_tunable)(struct phy_device *dev, struct ethtool_tunable *tuna, void *data);
    int (*set_tunable)(struct phy_device *dev,struct ethtool_tunable *tuna, const void *data);
    int (*set_loopback)(struct phy_device *dev, bool enable, int speed);
    int (*get_sqi)(struct phy_device *dev);
    int (*get_sqi_max)(struct phy_device *dev);
    int (*get_plca_cfg)(struct phy_device *dev, struct phy_plca_cfg *plca_cfg);
    int (*set_plca_cfg)(struct phy_device *dev, const struct phy_plca_cfg *plca_cfg);
    int (*get_plca_status)(struct phy_device *dev, struct phy_plca_status *plca_st);
    int (*led_brightness_set)(struct phy_device *dev, u8 index, enum led_brightness value);
    int (*led_blink_set)(struct phy_device *dev, u8 index,unsigned long *delay_on, unsigned long *delay_off);
    int (*led_hw_is_supported)(struct phy_device *dev, u8 index, unsigned long rules);
    int (*led_hw_control_set)(struct phy_device *dev, u8 index, unsigned long rules);
    int (*led_hw_control_get)(struct phy_device *dev, u8 index, unsigned long *rules);
    int (*led_polarity_set)(struct phy_device *dev, int index, unsigned long modes);
    unsigned int (*get_next_update_time)(struct phy_device *dev);
};

成員

mdiodrv

所有 MDIO 裝置共有的資料

phy_id

讀取此 PHY 型別的 UID 暫存器的結果，並將其與 phy_id_mask 進行 AND 運算。此驅動程式僅適用於 ID 與此欄位匹配的 PHY

name

此 PHY 型別的友好名稱

phy_id_mask

定義 phy_id 的重要位

features

此 PHY 支援的強制功能列表（速度、雙工等）

標誌

一個位欄位，定義此 PHY 支援的某些其他功能（例如中斷）

driver_data

靜態驅動程式資料

soft_reset

呼叫以發出 PHY 軟體重置

config_init

呼叫以初始化 PHY，包括在重置之後

probe

在發現期間呼叫。用於設定特定於裝置的結構（如果有）

get_features

探測硬體以確定其具有哪些能力。應僅設定 phydev->supported。

inband_caps

查詢給定 PHY 介面模式是否支援帶內。返回由 enum link_inband_signalling 定義的位的位掩碼。

config_inband

配置 PHY 的帶內模式

get_rate_matching

獲取特定 phy 介面支援的速率匹配型別。phy 使用者使用它來確定是否為該介面通告較低速度的模式。假設如果在介面上支援速率匹配模式，則可以使該介面的速率適應 phy 支援的所有較慢鏈路速度。如果不支援該介面，則應返回 RATE_MATCH_NONE。

suspend

掛起硬體，如果需要，則儲存狀態

resume

恢復硬體，如果需要，則恢復狀態

config_aneg

配置通告，如果 phydev->autoneg 已開啟，則重置自動協商，如果 phydev->autoneg 已關閉，則強制速度為 phydev 中的當前設定

aneg_done

確定自動協商結果

read_status

確定協商的速度和雙工

config_intr

啟用或停用中斷。它還應在啟用 IRQ 之前和停用 IRQ 之後清除任何掛起的中斷。

handle_interrupt

覆蓋預設中斷處理

remove

如果需要，清除任何記憶體

match_phy_device

如果這是給定 phydev 的合適驅動程式，則返回 true。如果為 NULL，則匹配基於 phy_id 和 phy_id_mask。

set_wol

某些裝置（例如 qnap TS-119P II）需要更改 PHY 暫存器才能啟用 Wake on LAN，因此提供了 set_wol 以便在乙太網驅動程式的 set_wol 函式中呼叫。

get_wol

請參閱 set_wol，但用於檢查是否啟用了 Wake on LAN。

link_change_notify

在核心即將更改鏈路狀態時，呼叫以通知 PHY 裝置驅動程式。此回撥應被用作修復程式掛鉤，用於需要在鏈路狀態更改時採取措施的驅動程式。驅動程式絕不允許在其實現中干擾 PHY 裝置結構。

read_mmd

讀取 MMD 暫存器的 PHY 特定驅動程式覆蓋。對於 PHY 特定驅動程式，此函式是可選的。如果未提供，phy_read_mmd() 將使用預設的 MMD 讀取函式，該函式將對 Clause 45 PHY 使用直接讀取，或對 Clause 22 PHY 使用間接讀取。devnum 是 PHY 裝置中的 MMD 裝置編號，regnum 是所選 MMD 裝置中的暫存器。

write_mmd

寫入 MMD 暫存器的 PHY 特定驅動程式覆蓋。對於 PHY 特定驅動程式，此函式是可選的。如果未提供，phy_write_mmd() 將使用預設的 MMD 寫入函式，該函式將對 Clause 45 PHY 使用直接寫入，或對 Clause 22 PHY 使用間接寫入。devnum 是 PHY 裝置中的 MMD 裝置編號，regnum 是所選 MMD 裝置中的暫存器。val 是要寫入的值。

read_page

返回當前 PHY 暫存器頁碼

write_page

設定當前 PHY 暫存器頁碼

module_info

獲取外掛模組中包含的 eeprom 的大小和型別

module_eeprom

從外掛模組獲取 eeprom 資訊

cable_test_start

啟動電纜測試

cable_test_tdr_start

啟動原始 TDR 電纜測試

cable_test_get_status

每秒一次或中斷時，請求測試狀態。

get_phy_stats

檢索 PHY 統計資訊。dev：為其檢索統計資訊的 PHY 裝置。eth_stats：將儲存乙太網 PHY 統計資訊的結構。stats：將儲存其他特定於 PHY 的統計資訊的結構。

檢索支援的 PHY 統計資訊並填充提供的結構。輸入結構使用 ETHTOOL_STAT_NOT_SET 進行預初始化，驅動程式必須僅修改與支援的統計資訊對應的成員。未修改的成員將保持設定為 ETHTOOL_STAT_NOT_SET，並且不會返回到使用者空間。

get_link_stats

檢索鏈路統計資訊。dev：為其檢索統計資訊的 PHY 裝置。link_stats：將儲存特定於鏈路的統計資訊的結構。

檢索給定 PHY 裝置的鏈路相關統計資訊。輸入結構使用 ETHTOOL_STAT_NOT_SET 進行預初始化，驅動程式必須僅修改與支援的統計資訊對應的成員。未修改的成員將保持設定為 ETHTOOL_STAT_NOT_SET，並且不會返回到使用者空間。

update_stats

觸發定期統計資訊更新。dev：為其觸發統計資訊更新的 PHY 裝置。

定期從 PHY 裝置收集統計資訊，以更新本地維護的 64 位計數器。這對於實現縮減寬度計數器（例如 16 位或 32 位）的 PHY 是必需的，這些計數器與 64 位計數器相比，可以更頻繁地溢位。透過呼叫此回撥，驅動程式可以獲取當前計數器值、處理溢位檢測並將結果累積到本地 64 位計數器中，以便透過 get_phy_stats 和 get_link_stats 介面進行準確報告。

返回值：成功時返回 0，失敗時返回負錯誤程式碼。

get_sset_count

統計計數器數量

get_strings

統計計數器的名稱

get_stats

返回統計計數器值

get_tunable

返回可調值

set_tunable

設定可調值

set_loopback

PHY的迴環模式使能選擇是否啟用迴環模式。如果啟用迴環模式，則可以使用 speed 引數請求迴環模式的速度。如果 speed 引數為零，則可以選擇任何速度。如果 speed 引數 > 0，則應為迴環模式選擇此速度，如果不支援速度選擇，則應返回 EOPNOTSUPP。

get_sqi

獲取訊號質量指示

get_sqi_max

獲取最大訊號質量指示

get_plca_cfg

返回當前的 PLCA 配置

set_plca_cfg

設定 PLCA 配置

get_plca_status

返回當前的 PLCA 狀態資訊

led_brightness_set

設定 PHY LED 亮度。Index 指示應設定哪個 PHY 的 LED。Value 遵循標準 LED 類的含義，例如 LED_OFF、LED_HALF、LED_FULL。

led_blink_set

設定 PHY LED 閃爍。Index 指示應配置為閃爍的 PHY 的哪個 LED。延遲以毫秒為單位，如果兩者都為零，則應選擇合理的預設值。呼叫應調整時間，如果它不能完全匹配指定的值。

led_hw_is_supported

硬體是否可以支援給定的規則。 dev: 具有 LED 的 PHY 裝置 index: PHY 裝置的哪個 LED rules: 核心對這些規則感興趣

如果支援則返回 0，如果不支援則返回 -EOPNOTSUPP，或返回一個錯誤程式碼。

led_hw_control_set

設定硬體以控制 LED dev: 具有 LED 的 PHY 裝置 index: PHY 裝置的哪個 LED rules: 用於控制 LED 的規則

返回 0，或一個錯誤程式碼。

led_hw_control_get

獲取硬體如何控制 LED dev: 具有 LED 的 PHY 裝置 index: PHY 裝置的哪個 LED rules: 指向用於控制 LED 的規則的指標

將 *rules 設定為硬體當前閃爍的方式。成功時返回 0，如果當前閃爍無法在規則中表示，或發生其他錯誤，則返回錯誤程式碼。

led_polarity_set

設定 LED 極性模式 dev: 具有 LED 的 PHY 裝置 index: PHY 裝置的哪個 LED modes: LED 極性模式的點陣圖

使用 modes 中的所有必需極性模式配置 LED，以使其正確地開啟或關閉。

返回 0，或一個錯誤程式碼。

get_next_update_time

獲取直到下一次更新事件的時間 dev: PHY 裝置

回撥以確定 PHY 狀態機的下一次更新事件的時間（以節拍為單位）。允許 PHY 驅動程式根據鏈路狀態或其他條件動態調整輪詢間隔。

返回直到下一次更新事件的時間（以節拍為單位）。

描述

所有函式都是可選的。如果 config_aneg 或 read_status 沒有實現，則 phy 核心使用 genphy 版本。請注意，這些函式都不應該從中斷時間呼叫。目標是匯流排讀取/寫入函式能夠在匯流排事務發生時阻塞，並被中斷釋放（MPC85xx 具有此能力，儘管目前在驅動程式中不支援）。

bool phy_id_compare(u32 id1, u32 id2, u32 mask)¶: 比較 id1 和 id2，考慮 mask

引數

u32 id1: 第一個 PHY ID
u32 id2: 第二個 PHY ID
u32 mask: PHY ID 掩碼，設定的位在匹配中很重要

描述

如果 mask 指定的 id1 和 id2 的位匹配，則返回 true。這使用等效於 (id & mask) == (phy_id & mask) 的測試。

bool phydev_id_compare(struct phy_device *phydev, u32 id)¶: 將 id 與 PHY 的 Clause 22 ID 進行比較

引數

struct phy_device *phydev: PHY 裝置
u32 id: 要匹配的 PHY ID

描述

將 phydev Clause 22 ID 與提供的 id 進行比較，並根據它是否匹配，使用繫結的驅動程式掩碼返回 true 或 false。phydev 必須繫結到驅動程式。

bool phy_is_started(struct phy_device *phydev)¶: 方便函式，用於檢查 PHY 是否已啟動

引數

struct phy_device *phydev: phy_device 結構

void phy_disable_eee_mode(struct phy_device *phydev, u32 link_mode)¶: 不通告 EEE 模式。

引數

struct phy_device *phydev: phy_device 結構
u32 link_mode: 要停用的 EEE 模式

int phy_read(struct phy_device *phydev, u32 regnum)¶: 方便函式，用於讀取給定的 PHY 暫存器

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要讀取的暫存器號

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int __phy_read(struct phy_device *phydev, u32 regnum)¶: 方便函式，用於讀取給定的 PHY 暫存器

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要讀取的暫存器號

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int phy_write(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於寫入給定的 PHY 暫存器

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int __phy_write(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於寫入給定的 PHY 暫存器

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int __phy_modify_changed(struct phy_device *phydev, u32 regnum, u16 mask, u16 set)¶: 用於修改 PHY 暫存器的便捷函式

引數

struct phy_device *phydev: 指向 struct phy_device 的指標
u32 regnum: 暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

描述

未鎖定的輔助函式，允許修改 PHY 暫存器，新暫存器值 = (舊暫存器值 & ~mask) | set

返回負 errno，如果沒有更改則返回 0，如果發生更改則返回 1

phy_read_mmd_poll_timeout¶

phy_read_mmd_poll_timeout (phydev, devaddr, regnum, val, cond, sleep_us, timeout_us, sleep_before_read)

定期輪詢 PHY 暫存器，直到滿足條件或發生超時

引數

物理鏈路拓撲跟蹤連線的 PHY: phy_device 結構
devaddr: 要從中讀取的MMD
regnum: 要讀取的MMD上的暫存器
val: 將暫存器讀入的變數
cond: 中斷條件（通常涉及 val）
sleep_us: 讀取之間休眠的最長時間，以微秒為單位（0 為緊密迴圈）。請閱讀 usleep_range() 函式描述，瞭解詳細資訊和限制。
timeout_us: 超時時間，以微秒為單位，0 表示從不超時
sleep_before_read: 如果為 true，則在讀取之前休眠 sleep_us。

返回 skb dst_entry

成功時為 0，超時時為 -ETIMEDOUT。在這兩種情況下，args 的最後讀取值都儲存在 val 中。如果使用 sleep_us 或 timeout_us，則不能從原子上下文中呼叫。

int __phy_set_bits(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於在 PHY 暫存器中設定位

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要設定的位

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int __phy_clear_bits(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於清除 PHY 暫存器中的位

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要清除的位

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int phy_set_bits(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於在 PHY 暫存器中設定位

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要設定的位

int phy_clear_bits(struct phy_device *phydev, u32 regnum, u16 val)¶: 方便函式，用於清除 PHY 暫存器中的位

引數

struct phy_device *phydev: phy_device 結構
u32 regnum: 要寫入的暫存器號
u16 val: 要清除的位

int __phy_set_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 方便函式，用於在 MMD 上的暫存器中設定位

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 val: 要設定的位

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int __phy_clear_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 方便函式，用於清除 MMD 上的暫存器中的位

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 val: 要清除的位

描述

呼叫者必須已獲得 MDIO 匯流排鎖。

int phy_set_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 方便函式，用於在 MMD 上的暫存器中設定位

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 val: 要設定的位

int phy_clear_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val)¶: 方便函式，用於清除 MMD 上的暫存器中的位

引數

struct phy_device *phydev: phy_device 結構
int devad: 包含要修改的暫存器的 MMD
u32 regnum: 要修改的暫存器號
u16 val: 要清除的位

bool phy_interrupt_is_valid(struct phy_device *phydev)¶: 方便函式，用於測試給定的 PHY irq

引數

struct phy_device *phydev: phy_device 結構

注意

必須與 PHY_POLL 和 PHY_MAC_INTERRUPT 的新增/刪除保持同步

bool phy_polling_mode(struct phy_device *phydev)¶: 方便函式，用於測試是否使用輪詢來檢測 PHY 狀態變化

引數

struct phy_device *phydev: phy_device 結構

bool phy_has_hwtstamp(struct phy_device *phydev)¶: 測試 PHY 是否具有時間戳配置。

引數

struct phy_device *phydev: phy_device 結構

bool phy_has_rxtstamp(struct phy_device *phydev)¶: 測試 PHY 是否支援接收時間戳。

引數

struct phy_device *phydev: phy_device 結構

bool phy_has_tsinfo(struct phy_device *phydev)¶: 測試 PHY 是否報告時間戳和/或 PTP 硬體時鐘功能。

引數

struct phy_device *phydev: phy_device 結構

bool phy_has_txtstamp(struct phy_device *phydev)¶: 測試 PHY 是否支援傳輸時間戳。

引數

struct phy_device *phydev: phy_device 結構

bool phy_is_default_hwtstamp(struct phy_device *phydev)¶: PHY hwtstamp 是否為預設時間戳

引數

struct phy_device *phydev: 指向 phy_device 的指標

描述

這用於獲取預設時間戳裝置，同時考慮到新的 API 選擇，如果 phydev 沒有啟用 default_timestamp 標誌，則預設情況下從 MAC 中選擇時間戳。

返回 skb dst_entry

如果 phy 是預設 hw 時間戳，則為 True，否則為 false。

bool phy_on_sfp(struct phy_device *phydev)¶: 方便函式，用於測試 PHY 是否位於 SFP 模組上

引數

struct phy_device *phydev: phy_device 結構

bool phy_interface_mode_is_rgmii(phy_interface_t mode)¶: 方便函式，用於測試 PHY 介面模式是否為 RGMII（所有變體）

引數

phy_interface_t mode: phy_interface_t 列舉

bool phy_interface_mode_is_8023z(phy_interface_t mode)¶: PHY 介面模式是否使用 802.3z 協商

引數

phy_interface_t mode: enum phy_interface_t 之一

描述

如果 PHY 介面模式使用 802.3z 中定義的 16 位協商字，則返回 true。（參見 802.3-2015 37.2.1 Config_Reg 編碼）

bool phy_interface_is_rgmii(struct phy_device *phydev)¶: 方便函式，用於測試 PHY 介面是否為 RGMII（所有變體）

引數

struct phy_device *phydev: phy_device 結構

bool phy_is_pseudo_fixed_link(struct phy_device *phydev)¶: 方便函式，用於測試此 PHY 是否為乙太網交換機的面向 CPU 埠的一側，或類似裝置。

引數

struct phy_device *phydev: phy_device 結構

phy_module_driver¶

phy_module_driver (__phy_drivers, __count)

用於註冊 PHY 驅動程式的輔助宏

引數

__phy_drivers: 要註冊的 PHY 驅動程式陣列
__count: 陣列中的成員數

描述

用於 PHY 驅動程式的輔助宏，這些驅動程式在模組初始化/退出時不做任何特殊操作。每個模組只能使用此宏一次，並且呼叫它將替換 module_init() 和 module_exit()。

int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)¶: 從列表中刪除 phy_fixup

引數

const char *bus_id: 一個字串匹配 phy_fixup_list 中的 fixup->bus_id（或 PHY_ANY_ID）
u32 phy_uid: 一個 phy id 匹配 phy_fixup_list 中的 fixup->phy_id（或 PHY_ANY_UID）
u32 phy_uid_mask: 應用於 phy_uid 和 fixup->phy_uid，然後再進行比較

int genphy_match_phy_device(struct phy_device *phydev, const struct phy_driver *phydrv)¶: 將 PHY 裝置與 PHY 驅動程式匹配

引數

struct phy_device *phydev: 目標 phy_device 結構
const struct phy_driver *phydrv: 目標 phy_driver 結構

描述

檢查給定的 PHY 裝置是否與指定的 PHY 驅動程式匹配。對於 Clause 45 PHY，它會迭代可用的裝置識別符號，並將它們與驅動程式的預期 PHY ID 進行比較，並應用提供的掩碼。對於 Clause 22 PHY，將執行直接 ID 比較。

返回 skb dst_entry

如果 PHY 裝置與驅動程式匹配，則為 1，否則為 0。

struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)¶: 讀取指定的 PHY 裝置並返回其 phy_device 結構

引數

struct mii_bus *bus: 目標 MII 匯流排
int addr: MII 總線上的 PHY 地址
bool is_c45: 如果為 true，則 PHY 使用 802.3 clause 45 協議

描述

在 bus 上的 addr 處探測 PHY。

當探測 clause 22 PHY 時，讀取 ID 暫存器。如果我們找到一個有效的 ID，則分配並返回一個 struct phy_device。

當探測 clause 45 PHY 時，讀取“封裝中的裝置”暫存器。如果“封裝中的裝置”看起來有效，則讀取每個 MMD 的 ID 暫存器，分配並返回一個 struct phy_device。

成功時返回一個已分配的 struct phy_device，如果不存在 PHY 則返回 -ENODEV，匯流排訪問錯誤時返回 -EIO。

int phy_device_register(struct phy_device *phydev)¶: 在 MDIO 總線上註冊 phy 裝置

引數

struct phy_device *phydev: 要新增到 MDIO 匯流排的 phy_device 結構

void phy_device_remove(struct phy_device *phydev)¶: 從 MDIO 匯流排中移除先前註冊的 phy 裝置

引數

struct phy_device *phydev: 要移除的 phy_device 結構

描述

這不會釋放 phy_device 本身，它僅僅反轉 phy_device_register() 的效果。在此函式呼叫後使用 phy_device_free() 釋放裝置。

int phy_get_c45_ids(struct phy_device *phydev)¶: 讀取 phy 裝置的 802.3-c45 ID。

引數

struct phy_device *phydev: 用於讀取 802.3-c45 ID 的 phy_device 結構

描述

成功時返回零，匯流排訪問錯誤時返回 -EIO，如果“封裝中的裝置”無效則返回 -ENODEV。

struct phy_device *phy_find_first(struct mii_bus *bus)¶: 查詢總線上的第一個 PHY 裝置

引數

struct mii_bus *bus: 目標 MII 匯流排

int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, void (*handler)(struct net_device*), phy_interface_t interface)¶: 將乙太網裝置連線到特定的 phy_device

引數

struct net_device *dev: 要連線的網路裝置
struct phy_device *phydev: 指向 phy 裝置的指標
void (*handler)(struct net_device *): 狀態更改通知的回撥函式
phy_interface_t interface: PHY 裝置的介面

struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, void (*handler)(struct net_device*), phy_interface_t interface)¶: 將乙太網裝置連線到 PHY 裝置

引數

struct net_device *dev: 要連線的網路裝置
const char *bus_id: 要連線的 PHY 裝置的 id 字串
void (*handler)(struct net_device *): 狀態更改通知的回撥函式
phy_interface_t interface: PHY 裝置的介面

描述

用於連線乙太網的便捷函式: 裝置到 PHY 裝置。預設行為是 PHY 基礎設施處理所有事情，並且僅在鏈路狀態更改時通知連線的驅動程式。如果您不想要或無法使用提供的功能，您可以選擇僅呼叫提供所需功能的函式子集。

void phy_disconnect(struct phy_device *phydev)¶: 停用中斷，停止狀態機，並分離 PHY 裝置

引數

struct phy_device *phydev: 目標 phy_device 結構

int phy_sfp_connect_phy(void *upstream, struct phy_device *phy)¶: 將 SFP 模組的 PHY 連線到上游 PHY

引數

void *upstream: 指向上游 phy 裝置的指標
struct phy_device *phy: 指向 SFP 模組的 phy 裝置的指標

描述

此助手允許跟蹤鏈路上的 PHY 裝置。它將 SFP 模組的 phy 新增到上游 phy 的 phy 名稱空間

返回 skb dst_entry

成功時返回 0，否則返回一個負錯誤程式碼。

void phy_sfp_disconnect_phy(void *upstream, struct phy_device *phy)¶: 從上游 PHY 斷開 SFP 模組的 PHY

引數

void *upstream: 指向上游 phy 裝置的指標
struct phy_device *phy: 指向 SFP 模組的 phy 裝置的指標

描述

此助手允許跟蹤鏈路上的 PHY 裝置。它將 SFP 模組的 phy 移除到上游 phy 的 phy 名稱空間。由於模組 phy 將被銷燬，因此重新插入同一模組將新增一個具有新索引的新 phy。

void phy_sfp_attach(void *upstream, struct sfp_bus *bus)¶: 將 SFP 匯流排連線到 PHY 上游網路裝置

引數

void *upstream: 指向 phy 裝置的指標
struct sfp_bus *bus: 表示正在連線的 cage 的 sfp 匯流排

描述

這用於填充 sfp_upstream_ops .attach 成員。

void phy_sfp_detach(void *upstream, struct sfp_bus *bus)¶: 從 PHY 上游網路裝置分離 SFP 匯流排

引數

void *upstream: 指向 phy 裝置的指標
struct sfp_bus *bus: 表示正在連線的 cage 的 sfp 匯流排

描述

這用於填充 sfp_upstream_ops .detach 成員。

int phy_sfp_probe(struct phy_device *phydev, const struct sfp_upstream_ops *ops)¶: 探測連線到此 PHY 裝置的 SFP cage

引數

struct phy_device *phydev: 指向 phy_device 的指標
const struct sfp_upstream_ops *ops: SFP 的上游操作

int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, u32 flags, phy_interface_t interface)¶: 將網路裝置連線到給定的 PHY 裝置指標

引數

struct net_device *dev: 要連線的網路裝置
struct phy_device *phydev: 指向要連線的 phy_device 的指標
u32 flags: PHY 裝置的 dev_flags
phy_interface_t interface: PHY 裝置的介面

描述

由驅動程式呼叫以連線到特定的 PHY: 裝置。找到 phy_device，並正確地連線到 phy_driver。如果沒有附加驅動程式，則使用通用驅動程式。為 phy_device 提供指向附加裝置的指標，並提供鏈路狀態更改的回撥。phy_device 被返回給附加驅動程式。此函式獲取對 phy 裝置的引用。

struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, phy_interface_t interface)¶: 將網路裝置連線到特定的 PHY 裝置

引數

struct net_device *dev: 要連線的網路裝置
const char *bus_id: 要連線的 PHY 裝置的匯流排 ID
phy_interface_t interface: PHY 裝置的介面

描述

與 phy_attach_direct() 相同，只是傳遞了 PHY bus_id: 字串，而不是指向 struct phy_device 的指標。

void phy_detach(struct phy_device *phydev)¶: 從其網路裝置分離 PHY 裝置

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

這會將 phy 裝置從其網路裝置和 phy 驅動程式中分離，並刪除在 phy_attach_direct() 中獲取的引用計數。

int phy_reset_after_clk_enable(struct phy_device *phydev)¶: 如果需要，執行 PHY 復位

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

已知某些 PHY 在啟用其 refclk 後需要復位: 啟用。此函式評估標誌，並在需要時執行復位。錯誤時返回 < 0，phy 未復位時返回 0，phy 已復位時返回 1。

int genphy_setup_forced(struct phy_device *phydev)¶: 從 phydev 配置/強制速度/雙工

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

配置 MII_BMCR 以強制速度/雙工: 為 phydev 中的值。假定這些值有效。請參閱 phy_sanitize_settings()。

int genphy_restart_aneg(struct phy_device *phydev)¶: 啟用並重新啟動自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構

int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)¶: 啟用並重新啟動自動協商

引數

struct phy_device *phydev: 目標 phy_device 結構
bool restart: 是否請求 aneg 重啟

描述

檢查，並在需要時重新啟動自動協商。

int __genphy_config_aneg(struct phy_device *phydev, bool changed)¶: 重新啟動自動協商或寫入 BMCR

引數

struct phy_device *phydev: 目標 phy_device 結構
bool changed: 是否請求自動協商

描述

如果啟用了自動協商，我們配置: 廣播，然後重新啟動自動協商。如果未啟用，則寫入 BMCR。

int genphy_c37_config_aneg(struct phy_device *phydev)¶: 重新啟動自動協商或寫入 BMCR

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

如果啟用了自動協商，我們配置: 廣播，然後重新啟動自動協商。如果未啟用，則寫入 BMCR。此函式旨在與 Clause 37 1000Base-X 模式一起使用。

int genphy_aneg_done(struct phy_device *phydev)¶: 返回自動協商狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

讀取狀態暫存器並返回 0，或者如果: 自動協商不完整，或者存在錯誤。如果自動協商完成，則返回 BMSR_ANEGCOMPLETE。

int genphy_update_link(struct phy_device *phydev)¶: 更新 phydev 中的鏈路狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

更新 phydev->link 中的值以反映: 當前鏈路值。為了做到這一點，我們需要讀取兩次狀態暫存器，保留第二個值。

int genphy_read_status_fixed(struct phy_device *phydev)¶: 讀取 !aneg 模式的鏈路引數

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

讀取停用了自動協商的 PHY 的當前雙工和速度狀態。

int genphy_read_status(struct phy_device *phydev)¶: 檢查鏈路狀態並更新當前鏈路狀態

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

檢查鏈路，然後確定當前狀態: 透過比較我們廣播的內容與鏈路夥伴廣播的內容。首先檢查千兆的可能性，然後繼續檢查 10/100。

int genphy_c37_read_status(struct phy_device *phydev, bool *changed)¶: 檢查鏈路狀態並更新當前鏈路狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
bool *changed: 指向儲存鏈路是否已更改的位置的指標

描述

檢查鏈路，然後確定當前狀態

透過比較我們廣播的內容與鏈路夥伴廣播的內容。此函式用於 Clause 37 1000Base-X 模式。

如果鏈路已更改，則將 changed 設定為 true，否則為 false。

int genphy_soft_reset(struct phy_device *phydev)¶: 透過 BMCR_RESET 位軟體復位 PHY

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

使用標準 BMCR_RESET 位執行軟體 PHY 復位，並輪詢復位位是否已清除。

返回 skb dst_entry

成功時返回 0，失敗時返回 < 0

int genphy_read_abilities(struct phy_device *phydev)¶: 從 Clause 22 暫存器讀取 PHY 功能

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

讀取 PHY 的功能並相應地填充 phydev->supported。

返回 skb dst_entry

成功時返回 0，失敗時返回 < 0

void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)¶: 移除受支援的鏈路模式

引數

struct phy_device *phydev: 用於從中移除鏈路模式的 phy_device 結構
u32 link_mode: 要移除的鏈路模式

描述

某些 MAC 不支援 PHY 支援的所有鏈路模式。例如，1G MAC 通常不支援 1000Half。新增一個助手以移除鏈路模式。

void phy_advertise_supported(struct phy_device *phydev)¶: 廣播所有支援的模式

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

呼叫以廣播所有支援的模式，不觸及暫停模式廣播。

void phy_advertise_eee_all(struct phy_device *phydev)¶: 廣播所有支援的 EEE 模式

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

預設情況下，phylib 會保留在 phy 探測時進行的 EEE 廣播，這可能是支援的 EEE 模式的子集。當應廣播所有支援的 EEE 模式時，請使用此函式。這不會觸發自動協商，因此必須在 phy_start()/ phylink_start() 之前呼叫，這將啟動自動協商。

void phy_support_eee(struct phy_device *phydev)¶: 設定初始 EEE 策略配置

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

此函式配置指定 PHY 裝置上的節能乙太網 (EEE) 的初始策略，從而影響在建立鏈路之前廣播 EEE 功能。如果 MAC 支援 LPI 或 PHY 能夠補償 MAC 缺少的 LPI 功能，則應由 MAC 驅動程式和/或 PHY 驅動程式（對於 SmartEEE PHY）在 PHY 註冊期間呼叫它。

該函式設定預設 EEE 策略引數，包括準備 PHY 以廣播基於硬體支援的 EEE 功能。

它還設定 MAC 驅動程式中低功耗空閒 (LPI) 的預期配置。如果 PHY 框架確定本地和遠端廣播都支援 EEE，並且協商的鏈路模式與 EEE 相容，則它將設定 enable_tx_lpi = true。MAC 驅動程式應透過在設定 enable_tx_lpi 時啟用 LPI 計時器來對此設定執行操作。

void phy_disable_eee(struct phy_device *phydev)¶: 停用 PHY 的 EEE

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

MAC 驅動程式使用此函式來處理不支援 EEE 的 MAC。它停用 PHY 層的 EEE。

void phy_support_sym_pause(struct phy_device *phydev)¶: 啟用對稱暫停的支援

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

由 MAC 呼叫以指示它支援對稱暫停，但不作為 asym 暫停。

void phy_support_asym_pause(struct phy_device *phydev)¶: 啟用 asym 暫停的支援

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

由 MAC 呼叫以指示它支援 Asym 暫停。

void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx, bool autoneg)¶: 配置對稱暫停

引數

struct phy_device *phydev: 目標 phy_device 結構
bool rx: 支援接收器暫停
bool tx: 支援傳輸暫停
bool autoneg: 應使用自動協商

描述

根據接收方是否支援暫停和暫停自動協商來配置通告的暫停支援。通常從 set_pauseparam .ndo 呼叫。

void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)¶: 配置暫停和非對稱暫停

引數

struct phy_device *phydev: 目標 phy_device 結構
bool rx: 支援接收器暫停
bool tx: 支援傳輸暫停

描述

根據是否支援傳送和接收暫停來配置通告的暫停支援。如果通告發生更改，則觸發新的自動協商。通常從 set_pauseparam .ndo 呼叫。

bool phy_validate_pause(struct phy_device *phydev, struct ethtool_pauseparam *pp)¶: 測試 PHY/MAC 是否支援暫停配置

引數

struct phy_device *phydev: phy_device 結構體
struct ethtool_pauseparam *pp: 請求的暫停配置

描述

測試 PHY/MAC 組合是否支援使用者請求的暫停配置。如果支援，則返回 True；否則返回 False。

void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)¶: 解析協商的暫停模式

引數

struct phy_device *phydev: phy_device 結構體
bool *tx_pause: 指向布林值的指標，指示是否應啟用傳送暫停。
bool *rx_pause: 指向布林值的指標，指示是否應啟用接收暫停。

描述

根據協商結果解析並返回流控制模式。這包括檢查我們是否在全雙工模式下執行。有關更多詳細資訊，請參閱 linkmode_resolve_pause()。

s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev, const int *delay_values, int size, bool is_rx)¶: 返回內部延遲的索引

引數

struct phy_device *phydev: phy_device 結構體
struct device *dev: 指向裝置裝置結構的指標
const int *delay_values: PHY 支援的延遲陣列
int size: 延遲陣列的大小
bool is_rx: 用於指示獲取 rx 內部延遲的布林值

描述

返回傳入的內部延遲陣列中的索引。如果裝置屬性不存在，則檢查介面型別，如果介面定義使用內部延遲，則返回 1，否則返回 0。陣列必須按升序排列。如果 PHY 沒有升序陣列，則 size = 0，並返回延遲屬性的值。如果延遲無效或找不到，則返回 -EINVAL。

int phy_get_tx_amplitude_gain(struct phy_device *phydev, struct device *dev, enum ethtool_link_mode_bit_indices linkmode, u32 *val)¶: 將 tx 幅度增益儲存在 val 中

引數

struct phy_device *phydev: phy_device 結構體
struct device *dev: 指向裝置裝置結構的指標
enum ethtool_link_mode_bit_indices linkmode: 應檢索 tx 幅度增益的 linkmode
u32 *val: tx 幅度增益

返回 skb dst_entry

成功時返回 0，失敗時返回 < 0

int phy_get_mac_termination(struct phy_device *phydev, struct device *dev, u32 *val)¶: 將 MAC 終端儲存在 val 中

引數

struct phy_device *phydev: phy_device 結構體
struct device *dev: 指向裝置裝置結構的指標
u32 *val: MAC 終端

返回 skb dst_entry

成功時返回 0，失敗時返回 < 0

struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)¶: 給定 fwnode，找到 mdio_device

引數

struct fwnode_handle *fwnode: 指向 mdio_device 的 fwnode 的指標

描述

如果成功，則返回指向 mdio_device 的指標，其中嵌入的 struct device 引用計數遞增 1，失敗則返回 NULL。呼叫者在使用後應在 mdio_device 上呼叫 put_device()。

struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)¶: 對於提供的 phy_fwnode，找到 phy_device。

引數

struct fwnode_handle *phy_fwnode: 指向 phy 的 fwnode 的指標。

描述

如果成功，則返回指向 phy_device 的指標，其中嵌入的 struct device 引用計數遞增 1，失敗則返回 NULL。

struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode)¶: 使用命名引用獲取 phy_node。

引數

const struct fwnode_handle *fwnode: 指向要從中獲取 phy_node 的 fwnode 的指標。

描述

請參閱 fwnode_find_reference() 的返回條件。對於 ACPI，僅支援“phy-handle”。 ACPI 中不支援舊版 DT 屬性“phy”和“phy-device”。 DT 支援對 phy 節點的所有三個命名引用。

int phy_driver_register(struct phy_driver *new_driver, struct module *owner)¶: 在 PHY 層註冊 phy_driver

引數

struct phy_driver *new_driver: 要註冊的新 phy_driver
struct module *owner: 擁有此 PHY 的模組

bool phy_uses_state_machine(struct phy_device *phydev)¶: 測試消費者驅動程式是否使用 PAL 狀態機

引數

struct phy_device *phydev: 目標 PHY 裝置結構

描述

最終，這旨在透過呼叫 phy_start() 和 phy_stop() 來間接確定 PHY 是否連線到使用狀態機的消費者。

當 PHY 驅動程式消費者使用 phylib 時，它必須先前呼叫 phy_connect_direct() 或其派生項之一，以便 phy_prepare_link() 已設定一個用於監視狀態更改的掛鉤。

當 PHY 驅動程式由透過 phylink 的 MAC 驅動程式消費者使用時（phy_link_change() 方法的唯一其他提供程式），使用 PHY 狀態機不是可選的。

返回 skb dst_entry

如果消費者呼叫 phy_start() 和 phy_stop()，則為 true；否則為 false。

int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, int (*run)(struct phy_device*))¶: 建立新的 phy_fixup 並將其新增到列表

引數

const char *bus_id: 一個字串，與 phydev->mdio.dev.bus_id（或 PHY_ANY_ID）匹配
u32 phy_uid: 用於匹配 phydev->phy_id（PHY 的 UID）。它也可以是 PHY_ANY_UID
u32 phy_uid_mask: 在比較之前應用於 phydev->phy_id 和 fixup->phy_uid
int (*run)(struct phy_device *): 找到匹配的 PHY 時要執行的實際程式碼

int get_phy_c45_ids(struct mii_bus *bus, int addr, struct phy_c45_device_ids *c45_ids)¶: 讀取指定地址的 802.3-c45 ID。

引數

struct mii_bus *bus: 目標 MII 匯流排
int addr: MII 總線上的 PHY 地址
struct phy_c45_device_ids *c45_ids: 在何處儲存 c45 ID 資訊。

描述

讀取 PHY “封裝中的裝置”。如果這看起來有效，則讀取每個裝置的 PHY 識別符號。在 c45_ids 中返回“封裝中的裝置”和識別符號。

成功返回零，匯流排訪問錯誤返回 -EIO，如果“封裝中的裝置”無效或沒有裝置響應，則返回 -ENODEV。

int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id)¶: 讀取指定地址的 clause 22 ID。

引數

struct mii_bus *bus: 目標 MII 匯流排
int addr: MII 總線上的 PHY 地址
u32 *phy_id: 在何處儲存檢索到的 ID。

描述

從 bus 上的 addr 處的 PHY 讀取 802.3 clause 22 PHY ID，並將其放在 phy_id 中。成功讀取且 ID 有效時返回零，匯流排訪問錯誤返回 -EIO，如果裝置不響應或 ID 無效，則返回 -ENODEV。

void phy_prepare_link(struct phy_device *phydev, void (*handler)(struct net_device*))¶: 準備 PHY 層以監視鏈路狀態

引數

struct phy_device *phydev: 目標 phy_device 結構
void (*handler)(struct net_device *): 用於鏈路狀態更改通知的回撥函式

描述

告訴 PHY 基礎結構處理: 監視鏈路狀態的詳細資訊（無論是透過輪詢還是中斷），並在鏈路狀態更改時回撥到連線的裝置驅動程式。如果要監視自己的鏈路狀態，請不要呼叫此函式。

int phy_poll_reset(struct phy_device *phydev)¶: 安全地等待，直到 PHY 復位正確完成

引數

struct phy_device *phydev: 要輪詢的 PHY 裝置

描述

根據 IEEE 802.3 第 2 節，第 22.2.4.1.1 小節，

於 2008 年釋出，PHY 復位最多可能需要 0.5 秒。必須輪詢 MII BMCR 暫存器，直到 BMCR_RESET 位清除。

此外，在此完成之前，任何寫入 PHY 暫存器的嘗試都可能無效，甚至可能生成 MDIO 匯流排錯誤。

某些 PHY（例如 Marvell 88E1111）並不完全符合標準，並且在設定 BMCR_RESET 位後不會完全復位，甚至可能需要軟復位才能正確重新啟動自動協商。為了支援此類損壞的 PHY，此函式與標準 phy_init_hw() 分開，後者將清除 BMCR 中的所有其他位並重新應用所有特定於驅動程式和特定於板的修復程式。

int genphy_config_advert(struct phy_device *phydev, const unsigned long *advert)¶: 清理和通告自動協商引數

引數

struct phy_device *phydev: 目標 phy_device 結構
const unsigned long *advert: 要通告的自動協商引數

描述

使用適當的值寫入 MII_ADVERTISE，: 在清理值以確保我們只通告支援的內容之後。錯誤時返回 < 0，如果 PHY 的通告沒有更改，則返回 0，如果已更改，則返回 > 0。

int genphy_c37_config_advert(struct phy_device *phydev)¶: 清理和通告自動協商引數

引數

struct phy_device *phydev: 目標 phy_device 結構

描述

使用適當的值寫入 MII_ADVERTISE，: 在清理值以確保我們只通告支援的內容之後。錯誤時返回 < 0，如果 PHY 的通告沒有更改，則返回 0，如果已更改，則返回 > 0。此函式適用於 Clause 37 1000Base-X 模式。

int phy_probe(struct device *dev)¶: 探測和初始化 PHY 裝置

引數

struct device *dev: 要探測和初始化的裝置

描述

注意設定 phy_device 結構，並將狀態設定為 READY。

struct mii_bus *mdio_find_bus(const char *mdio_name)¶: 給定 mdiobus 的名稱，找到 mii_bus。

引數

const char *mdio_name: mdiobus 的名稱。

描述

返回對 mii_bus 的引用，如果未找到，則返回 NULL。嵌入的 struct device 將遞增其引用計數，並且一旦匯流排完成，就必須 put_deviced’ed。

struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)¶: 給定一個 mii_bus 節點，找到 mii_bus。

引數

struct device_node *mdio_bus_np: 指向 mii_bus 的指標。

描述

返回對 mii_bus 的引用，如果未找到，則返回 NULL。嵌入的 struct device 將遞增其引用計數，並且必須在匯流排完成後 put。

由於 device_node 和 mii_bus 的關聯是透過 of_mdiobus_register() 建立的，因此在透過 of_mdiobus_register() 註冊之前無法找到 mii_bus。

int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)¶: mdiobus_read 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要讀取的暫存器號

描述

讀取 MDIO 匯流排暫存器。呼叫者必須持有 mdio 匯流排鎖。

注意

不得從中斷上下文呼叫。

int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)¶: mdiobus_write 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

描述

寫入 MDIO 匯流排暫存器。呼叫者必須持有 mdio 匯流排鎖。

注意

不得從中斷上下文呼叫。

int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)¶: mdiobus_modify 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

描述

讀取、修改，如果發生任何更改，則將暫存器值寫回裝置。任何錯誤都將返回一個負數。

注意

不得從中斷上下文呼叫。

int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)¶: mdiobus_c45_read 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要讀取的暫存器號

描述

讀取 MDIO 匯流排暫存器。呼叫者必須持有 mdio 匯流排鎖。

注意

不得從中斷上下文呼叫。

int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 val)¶: mdiobus_write 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

描述

寫入 MDIO 匯流排暫存器。呼叫者必須持有 mdio 匯流排鎖。

注意

不得從中斷上下文呼叫。

int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)¶: mdiobus_read 函式的巢狀版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要讀取的暫存器號

描述

對於巢狀的 MDIO 匯流排訪問，請使用 mutex_lock_nested() 避免鎖依賴誤報。

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)¶: 用於讀取給定 MII 管理暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要讀取的暫存器號

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)¶: 用於讀取給定 MII 管理暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要讀取的暫存器號

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad, u32 regnum)¶: mdiobus_c45_read 函式的巢狀版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要讀取的暫存器號

描述

對於巢狀的 MDIO 匯流排訪問，請使用 mutex_lock_nested() 避免鎖依賴誤報。

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)¶: mdiobus_write 函式的巢狀版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

描述

對於巢狀的 MDIO 匯流排訪問，請使用 mutex_lock_nested() 避免鎖依賴誤報。

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)¶: 用於寫入給定 MII 管理暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 val)¶: 用於寫入給定 MII 管理暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 val)¶: mdiobus_c45_write 函式的巢狀版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要寫入的暫存器號
u16 val: 要寫入 **regnum** 的值

描述

對於巢狀的 MDIO 匯流排訪問，請使用 mutex_lock_nested() 避免鎖依賴誤報。

注意

不得從中斷上下文中呼叫，因為匯流排讀取/寫入函式可能會等待中斷完成操作。

int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)¶: 用於修改給定 mdio 裝置暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要寫入的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改給定 mdio 裝置暫存器的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要寫入的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)¶: 用於修改給定 mdio 裝置暫存器並在更改時返回的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
u32 regnum: 要寫入的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 mask, u16 set)¶: 用於修改給定 mdio 裝置暫存器並在更改時返回的便捷函式

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要寫入的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

void mdiobus_release(struct device *d)¶: mii_bus 裝置釋放回調

引數

struct device *d: 包含 mii_bus 的目標 struct device

描述

當對 mii_bus 的最後一次引用被刪除時呼叫，以釋放底層記憶體。

int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad, u32 regnum, u16 mask, u16 set)¶: mdiobus_modify 函式的解鎖版本

引數

struct mii_bus *bus: mii_bus 結構
int addr: phy 地址
int devad: 要讀取的裝置地址
u32 regnum: 要修改的暫存器號
u16 mask: 要清除的位的位掩碼
u16 set: 要設定的位的位掩碼

描述

讀取、修改，如果發生任何更改，則將暫存器值寫回裝置。任何錯誤都將返回一個負數。

注意

不得從中斷上下文呼叫。

int mdio_bus_match(struct device *dev, const struct device_driver *drv)¶: 確定給定的 MDIO 驅動程式是否支援給定的 MDIO 裝置

引數

struct device *dev: 目標 MDIO 裝置
const struct device_driver *drv: 給定的 MDIO 驅動程式

描述

給定一個 MDIO 裝置和一個 MDIO 驅動程式，如果: 驅動程式支援該裝置，則返回 1。否則，返回 0。這可能需要呼叫裝置自己的匹配函式，因為不同型別的 MDIO 裝置具有不同的匹配標準。

PHYLINK¶

PHYLINK 將傳統的網路驅動程式與 PHYLIB、固定鏈路和 SFF 模組（例如，熱插拔 SFP）連線起來，這些模組可能包含 PHY。PHYLINK 提供鏈路狀態和鏈路模式的管理。

struct phylink_link_state¶: 鏈路狀態結構

定義:

struct phylink_link_state {
    unsigned long advertising[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    unsigned long lp_advertising[BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS)];
    phy_interface_t interface;
    int speed;
    int duplex;
    int pause;
    int rate_matching;
    unsigned int link:1;
    unsigned int an_complete:1;
};

成員

advertising: 包含通告的鏈路模式的 ethtool 位掩碼
lp_advertising: 包含鏈路夥伴通告的鏈路模式的 ethtool 位掩碼
interface: 鏈路 typedef phy_interface_t 模式
speed: 鏈路速度，SPEED_* 常量之一。
duplex: 鏈路雙工模式，DUPLEX_* 常量之一。
pause: 鏈路暫停狀態，由 MLO_PAUSE_* 常量描述。
rate_matching: 正在執行的速率匹配，RATE_MATCH_* 常量之一。如果正在進行速率匹配，則介質鏈路模式（speed 和 duplex）的速度/雙工和 phy 介面模式（interface）的速度/雙工不同。
link: 如果鏈路已啟動，則為真。
an_complete: 如果自動協商已完成，則為真。

struct phylink_config¶: PHYLINK 配置結構

定義:

struct phylink_config {
    struct device *dev;
    enum phylink_op_type type;
    bool poll_fixed_state;
    bool mac_managed_pm;
    bool mac_requires_rxc;
    bool default_an_inband;
    bool eee_rx_clk_stop_enable;
    void (*get_fixed_state)(struct phylink_config *config, struct phylink_link_state *state);
    unsigned long supported_interfaces[BITS_TO_LONGS(PHY_INTERFACE_MODE_MAX)];
    unsigned long lpi_interfaces[BITS_TO_LONGS(PHY_INTERFACE_MODE_MAX)];
    unsigned long mac_capabilities;
    unsigned long lpi_capabilities;
    u32 lpi_timer_default;
    bool eee_enabled_default;
};

成員

dev: 指向與 MAC 關聯的 struct device 的指標
型別: PHYLINK 例項的操作型別
poll_fixed_state: 如果為真，則啟動 link_poll，如果 MAC 鏈路處於 MLO_AN_FIXED 模式。
mac_managed_pm: 如果為真，則表示 MAC 驅動程式負責 PHY PM。
mac_requires_rxc: 如果為真，則 MAC 始終需要來自 PHY 的接收時鐘。PHY 驅動程式應儘快啟動時鐘訊號，並避免在掛起事件期間停止它。
default_an_inband: 如果為真，則預設為 MLO_AN_INBAND 而不是 MLO_AN_PHY。固定鏈路規範將覆蓋。
eee_rx_clk_stop_enable: 如果為真，則 PHY 可以在 LPI 期間停止接收時鐘
get_fixed_state: 如果 MAC 鏈路處於 MLO_AN_FIXED 模式，則執行的回撥以確定固定鏈路狀態。
supported_interfaces: 點陣圖，描述 MAC/PCS 支援哪些 PHY_INTERFACE_MODE_xxx。
lpi_interfaces: 點陣圖，描述哪些 PHY 介面模式可以支援 LPI 信令。
mac_capabilities: MAC 暫停/速度/雙工功能。
lpi_capabilities: 可以支援 LPI 信令的 MAC 速度
lpi_timer_default: 預設 EEE LPI 計時器設定。
eee_enabled_default: 如果設定，則 EEE 將在建立時由 phylink 啟用

struct phylink_mac_ops¶: MAC 操作結構。

定義:

struct phylink_mac_ops {
    unsigned long (*mac_get_caps)(struct phylink_config *config, phy_interface_t interface);
    struct phylink_pcs *(*mac_select_pcs)(struct phylink_config *config, phy_interface_t interface);
    int (*mac_prepare)(struct phylink_config *config, unsigned int mode, phy_interface_t iface);
    void (*mac_config)(struct phylink_config *config, unsigned int mode, const struct phylink_link_state *state);
    int (*mac_finish)(struct phylink_config *config, unsigned int mode, phy_interface_t iface);
    void (*mac_link_down)(struct phylink_config *config, unsigned int mode, phy_interface_t interface);
    void (*mac_link_up)(struct phylink_config *config,struct phy_device *phy, unsigned int mode,phy_interface_t interface, int speed, int duplex, bool tx_pause, bool rx_pause);
    void (*mac_disable_tx_lpi)(struct phylink_config *config);
    int (*mac_enable_tx_lpi)(struct phylink_config *config, u32 timer, bool tx_clk_stop);
};

成員

mac_get_caps: 獲取介面模式的 MAC 功能。
mac_select_pcs: 為介面模式選擇 PCS。
mac_prepare: 準備對介面進行重大重新配置。
mac_config: 為所選模式和狀態配置 MAC。
mac_finish: 完成介面的重大重新配置。
mac_link_down: 關閉鏈路。
mac_link_up: 允許鏈路啟動。
mac_disable_tx_lpi: 停用 LPI。
mac_enable_tx_lpi: 啟用和配置 LPI。

描述

各個方法將在下面更全面地描述。

unsigned long mac_get_caps(struct phylink_config *config, phy_interface_t interface)¶: 獲取介面模式的 MAC 功能。

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
phy_interface_t interface: PHY 介面模式。

描述

可選方法。未提供時，將使用 config->mac_capabilities。實施時，這將返回指定介面模式的 MAC 功能，其中 MAC 驅動程式需要進行一些特殊處理（例如，不支援某些介面模式下的半雙工。）

struct phylink_pcs *mac_select_pcs(struct phylink_config *config, phy_interface_t interface)¶: 為介面模式選擇 PCS。

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
phy_interface_t interface: 用於 PCS 的 PHY 介面模式

描述

返回指定介面模式的 struct phylink_pcs，如果不需要，則返回 NULL，如果出錯，則返回錯誤指標。

這不得修改任何狀態。它用於查詢應使用哪個 PCS。Phylink 將在驗證期間使用它來確保配置有效，並在設定配置時在內部設定將使用的 PCS。

int mac_prepare(struct phylink_config *config, unsigned int mode, phy_interface_t iface)¶: 準備更改 PHY 介面模式

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
unsigned int mode: 之一 MLO_AN_FIXED, MLO_AN_PHY, MLO_AN_INBAND.
phy_interface_t iface: 要切換到的介面模式

描述

phylink 將在鏈路完全初始化的開始時呼叫此方法，這包括更改介面模式或在初始啟動時呼叫。可能會為當前模式呼叫它。MAC 驅動程式應執行所需的任何操作，例如，停用 Serdes PHY。

這將是序列中的第一個呼叫：- mac_prepare() - mac_config() - pcs_config() - 可能 pcs_an_restart() - mac_finish()

成功時返回零，失敗時返回負 errno，這將報告給核心日誌。

void mac_config(struct phylink_config *config, unsigned int mode, const struct phylink_link_state *state)¶: 為所選模式和狀態配置 MAC

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
unsigned int mode: 之一 MLO_AN_FIXED, MLO_AN_PHY, MLO_AN_INBAND.
const struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。

描述

注意 - state 的並非所有成員都有效。特別是，不能保證 state->lp_advertising、state->link、state->an_complete 正確，因此任何 mac_config() 實現都絕不能引用這些欄位。

僅當重新配置 MAC 以進行“重大”更改時才會呼叫此方法，例如，介面模式。不會為速度、雙工或暫停模式的更改或更改帶內通告而呼叫此方法。

在所有協商模式中（由 mode 定義），state->pause 指示應應用的暫停設定，如下所示。如果未設定 MLO_PAUSE_AN，則 MLO_PAUSE_TX 和 MLO_PAUSE_RX 分別指示 MAC 是否應傳送暫停幀和/或對接收到的暫停幀起作用。否則，應使用 MAC PCS 的帶內協商/狀態的結果來控制 MAC 暫停模式設定。

執行的操作取決於當前選擇的模式

MLO_AN_FIXED, MLO_AN_PHY

配置為非帶內協商模式，其中鏈路設定完全透過 mac_link_up() 通訊。來自 MAC 的物理鏈路協議由 state->interface 指定。

可以使用 state->advertising，但不是必需的。

較舊的驅動程式（在 mac_link_up() 更改之前）可以使用 state->speed、state->duplex 和 state->pause 來配置 MAC，但不建議這樣做；應將此類驅動程式轉換為使用 mac_link_up()。

必須忽略 state 的其他成員。

有效的狀態成員：interface、advertising。不建議使用的狀態成員：speed、duplex、pause。

MLO_AN_INBAND:

將鏈路置於帶內協商模式（例如，取決於 state->interface 模式的 802.3z 1000base-X 或 Cisco SGMII 模式）。在這兩種情況下，鏈路狀態管理（鏈路是否啟動）都由 MAC 執行，並透過 pcs_get_state() 回撥報告。鏈路狀態的更改必須透過呼叫 phylink_mac_change() 來進行。

下面提到了介面模式特定詳細資訊。

如果在 802.3z 模式下，鏈路速度是固定的，具體取決於 state->interface。雙工和暫停模式透過帶內配置字協商。根據 state->an_enabled 和 state->advertising 標誌設定通告的暫停模式。請注意僅在千兆及更高速度下支援全雙工的 MAC。

如果在 Cisco SGMII 模式下，鏈路速度和雙工模式在序列位元流 16 位配置字中傳遞，應將 MAC 配置為讀取這些位並確認配置字。MAC 不會通告任何內容。MAC 負責讀取配置字並相應地配置自身。

有效的狀態成員：interface、an_enabled、pause、advertising。

預期實施會更新 MAC 以反映請求的設定 - 也就是說，如果在兩次呼叫之間沒有任何更改，則不應執行任何操作。如果僅更改了流控制設定，則應更新流控制，而無需關閉鏈路。此“更新”行為對於避免使鏈路啟動狀態反彈至關重要。

int mac_finish(struct phylink_config *config, unsigned int mode, phy_interface_t iface)¶: 完成以更改 PHY 介面模式

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
unsigned int mode: 之一 MLO_AN_FIXED, MLO_AN_PHY, MLO_AN_INBAND.
phy_interface_t iface: 要切換到的介面模式

描述

如果 phylink 呼叫了 mac_prepare()，它將呼叫此方法，以允許 MAC 在為 mode 和 iface 配置 MAC 和 PCS 後完成任何必要步驟。例如，MAC 驅動程式可能希望在此處重新啟用 Serdes PHY，如果之前已被 mac_prepare() 停用。

成功時返回零，失敗時返回負 errno，這將報告給核心日誌。

void mac_link_down(struct phylink_config *config, unsigned int mode, phy_interface_t interface)¶: 鏈路已關閉的通知

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
unsigned int mode: 鏈路自動協商模式
phy_interface_t interface: 鏈路 typedef phy_interface_t 模式

描述

通知 MAC 鏈路已關閉。除非之前呼叫了 mac_link_up()，否則不會呼叫此方法。

MAC 應停止處理用於傳輸和接收的資料包。phylink 將呼叫 netif_carrier_off() 以通知網路堆疊鏈路已關閉，因此 MAC 驅動程式不應進行此呼叫。

如果 mode 是 MLO_AN_INBAND，則此函式不得阻止鏈路啟動。

void mac_link_up(struct phylink_config *config, struct phy_device *phy, unsigned int mode, phy_interface_t interface, int speed, int duplex, bool tx_pause, bool rx_pause)¶: 鏈路已啟動的通知

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
struct phy_device *phy: 任何連線的 phy（不建議使用 - 請使用 LPI 介面）
unsigned int mode: 鏈路自動協商模式
phy_interface_t interface: 鏈路 typedef phy_interface_t 模式
int speed: 鏈路速度
int duplex: 鏈路雙工
bool tx_pause: 鏈路傳輸暫停啟用狀態
bool rx_pause: 鏈路接收暫停啟用狀態

描述

通知 MAC 鏈路已啟動，以及從 MAC 的角度來看的鏈路引數。如果之前呼叫了 mac_link_up()，則在此方法隨後被呼叫之前，將有一個對 mac_link_down() 的中間呼叫。

speed、duplex、tx_pause 和 rx_pause 指示最終確定的鏈路設定，應使用這些設定來適當地配置 MAC 塊，如果這些設定不是從 PCS 塊自動傳送，或者如果停用了帶內協商（由 phylink_autoneg_inband(mode) 定義）。

請注意，當使用 802.3z 帶內協商時，使用者可能希望覆蓋暫停設定，並且在考慮此方法的實施時應允許這樣做。

配置完成後，MAC 可能會開始處理用於傳輸和接收的資料包。

介面型別選擇必須在 mac_config() 中完成。

void mac_disable_tx_lpi(struct phylink_config *config)¶: 在 MAC 處停用 LPI 生成

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。

描述

在 MAC 處停用 LPI 生成，從而有效地阻止 MAC 指示其處於空閒狀態。

int mac_enable_tx_lpi(struct phylink_config *config, u32 timer, bool tx_clk_stop)¶: 配置並啟用 MAC 處的 LPI 生成

引數

struct phylink_config *config: 指向 struct phylink_config 的指標。
u32 timer: 以微秒為單位的 LPI 超時。
bool tx_clk_stop: 允許在 LPI 期間停止 xMII 傳輸時鐘

描述

相應地配置 LPI 超時。僅當鏈路已啟動時才會呼叫此方法，以適應需要根據鏈路速度對硬體進行程式設計的情況。

啟用 MAC 處的 LPI 生成，並配置是否可以停止 xMII 傳輸時鐘。

返回 skb dst_entry

0 表示成功。返回錯誤之前請諮詢 rmk。

struct phylink_pcs¶: PHYLINK PCS 例項

定義:

struct phylink_pcs {
    unsigned long supported_interfaces[BITS_TO_LONGS(PHY_INTERFACE_MODE_MAX)];
    const struct phylink_pcs_ops *ops;
    struct phylink *phylink;
    bool poll;
    bool rxc_always_on;
};

成員

supported_interfaces: 描述此 PCS 支援哪些 PHY_INTERFACE_MODE_xxx。
ops: 指向 struct phylink_pcs_ops 結構的指標
phylink: 指向 struct phylink_config 的指標
輪詢: 輪詢 PCS 以獲取鏈路更改
rxc_always_on: MAC 驅動程式需要參考時鐘始終開啟。獨立的 PCS 驅動程式無法訪問 PHY 裝置，可以檢查此項而不是 PHY_F_RXC_ALWAYS_ON。

描述

此結構旨在嵌入在 PCS 私有資料中，並在 phylink 和 PCS 之間傳遞。

phylink 成員是 phylink 的私有成員，PCS 驅動程式不得觸碰。

struct phylink_pcs_ops¶: MAC PCS 操作結構。

定義:

struct phylink_pcs_ops {
    int (*pcs_validate)(struct phylink_pcs *pcs, unsigned long *supported, const struct phylink_link_state *state);
    unsigned int (*pcs_inband_caps)(struct phylink_pcs *pcs, phy_interface_t interface);
    int (*pcs_enable)(struct phylink_pcs *pcs);
    void (*pcs_disable)(struct phylink_pcs *pcs);
    void (*pcs_pre_config)(struct phylink_pcs *pcs, phy_interface_t interface);
    int (*pcs_post_config)(struct phylink_pcs *pcs, phy_interface_t interface);
    void (*pcs_get_state)(struct phylink_pcs *pcs, unsigned int neg_mode, struct phylink_link_state *state);
    int (*pcs_config)(struct phylink_pcs *pcs, unsigned int neg_mode,phy_interface_t interface,const unsigned long *advertising, bool permit_pause_to_mac);
    void (*pcs_an_restart)(struct phylink_pcs *pcs);
    void (*pcs_link_up)(struct phylink_pcs *pcs, unsigned int neg_mode, phy_interface_t interface, int speed, int duplex);
    void (*pcs_disable_eee)(struct phylink_pcs *pcs);
    void (*pcs_enable_eee)(struct phylink_pcs *pcs);
    int (*pcs_pre_init)(struct phylink_pcs *pcs);
};

成員

pcs_validate: 驗證鏈路配置。
pcs_inband_caps: 查詢介面模式的帶內支援。
pcs_enable: 啟用 PCS。
pcs_disable: 停用 PCS。
pcs_pre_config: pre-mac_config 方法 (用於勘誤)
pcs_post_config: post-mac_config 方法 (用於勘誤)
pcs_get_state: 從硬體讀取當前 MAC PCS 鏈路狀態。
pcs_config: 配置 MAC PCS 以用於所選模式和狀態。
pcs_an_restart: 重新啟動 802.3z BaseX 自動協商。
pcs_link_up: 為已解析的鏈路配置程式設計 PCS（如果需要）。
pcs_disable_eee: PCS 的可選通知，表明 EEE 已在 MAC 中停用。
pcs_enable_eee: PCS 的可選通知，表明 EEE 即將在 MAC 中啟用。
pcs_pre_init: 配置 MAC 硬體初始化所需的 PCS 元件，例如 stmmac 的 RX 時鐘。

int pcs_validate(struct phylink_pcs *pcs, unsigned long *supported, const struct phylink_link_state *state)¶: 驗證鏈路配置。

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。
unsigned long *supported: 支援的鏈路模式的 ethtool 位掩碼。
const struct phylink_link_state *state: 指向 struct phylink_link_state 的常量指標。

描述

驗證介面模式和通告的自動協商位，從支援的掩碼中刪除任何不支援的媒體 ethtool 鏈路模式。Phylink 會將更改傳播到通告掩碼。請參閱 struct phylink_mac_ops validate() 方法。

如果不支援介面模式/自動協商模式，則返回 -EINVAL。如果可以支援鏈路狀態，則返回非零正值。

unsigned int pcs_inband_caps(struct phylink_pcs *pcs, phy_interface_t interface)¶: 查詢介面模式的 PCS 帶內功能。

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。
phy_interface_t interface: 要查詢的介面模式

描述

如果不知道 PHY 支援哪些帶內信令，則返回零（例如，因為 PHY 驅動程式未實現該方法）。否則，返回 LINK_INBAND_* 值的位掩碼，該值來自 enum link_inband_signalling，用於描述此介面模式支援哪些帶內模式。

int pcs_enable(struct phylink_pcs *pcs)¶: 啟用 PCS。

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。

void pcs_disable(struct phylink_pcs *pcs)¶: 停用 PCS。

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。

void pcs_get_state(struct phylink_pcs *pcs, unsigned int neg_mode, struct phylink_link_state *state)¶: 從硬體讀取當前帶內鏈路狀態

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。
unsigned int neg_mode: 鏈路協商模式 (PHYLINK_PCS_NEG_xxx)
struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。

描述

從 MAC PCS 讀取當前的帶內鏈路狀態，使用 MLO_PAUSE_RX 和 MLO_PAUSE_TX 位在 state->speed 中報告當前速度，在 state->duplex 中報告雙工模式，在 state->pause 中報告暫停模式，在 state->an_complete 中報告協商完成狀態，在 state->link 中報告鏈路啟動狀態。如果可能，還應填充 state->lp_advertising。

請注意，neg_mode 引數始終是 PHYLINK_PCS_NEG_xxx 狀態，而不是 MLO_AN_xxx。

int pcs_config(struct phylink_pcs *pcs, unsigned int neg_mode, phy_interface_t interface, const unsigned long *advertising, bool permit_pause_to_mac)¶: 配置 PCS 模式和通告

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。
unsigned int neg_mode: 鏈路協商模式（見下文）
phy_interface_t interface: 要使用的介面模式
const unsigned long *advertising: 通告 ethtool 鏈路模式掩碼
bool permit_pause_to_mac: 允許將暫停解析轉發到 MAC

描述

為操作模式、介面模式配置 PCS，並設定通告掩碼。 permit_pause_to_mac 指示硬體是否可以將暫停模式解析轉發到 MAC。

在 MLO_AN_INBAND 中操作時，應始終啟用帶內，否則應停用帶內。

對於 SGMII，MAC 端沒有通告，應將 PCS 程式設計為確認來自 PHY 的帶內字。

對於 1000BASE-X，應將通告程式設計到 PCS 中。

對於大多數 10GBASE-R，沒有通告。

應透過 phylink_mode_*() 系列函式測試 neg_mode 引數，或者對於設定 pcs->neg_mode 為 true 的 PCS，應根據 PHYLINK_PCS_NEG_* 定義進行測試。

當需要配置 PCS 或可能更新通告時，將呼叫 pcs_config()。它不得不必要地中斷已建立的鏈路。

當 802.3z 模式需要自動協商重啟時，.pcs_config() 應返回一個正的非零整數（例如 1），以指示 phylink 呼叫 pcs_an_restart() 方法。

void pcs_an_restart(struct phylink_pcs *pcs)¶: 重新啟動 802.3z BaseX 自動協商

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。

描述

當存在 PCS 操作時，這將覆蓋 struct phylink_mac_ops 中的 mac_an_restart()。

void pcs_link_up(struct phylink_pcs *pcs, unsigned int neg_mode, phy_interface_t interface, int speed, int duplex)¶: 為已解析的鏈路配置程式設計 PCS

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。
unsigned int neg_mode: 鏈路協商模式（見下文）
phy_interface_t interface: 鏈路 typedef phy_interface_t 模式
int speed: 鏈路速度
int duplex: 鏈路雙工

描述

將在 mac_link_up() 之前呼叫此函式，以通知 PCS 已解析的鏈路引數。例如，在沒有帶內 AN 的 SGMII 模式下執行的 PCS 需要手動配置鏈路和雙工設定。否則，這應該是一個空操作。

應透過 phylink_mode_*() 系列函式測試 mode 引數，或者對於設定 pcs->neg_mode 為 true 的 PCS，應根據 PHYLINK_PCS_NEG_* 定義進行測試。

void pcs_disable_eee(struct phylink_pcs *pcs)¶: 在 PCS 中停用 EEE

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標

描述

可選方法，通知 PCS EEE 已在 MAC 中停用。

void pcs_enable_eee(struct phylink_pcs *pcs)¶: 在 PCS 中啟用 EEE

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標

描述

可選方法，通知 PCS 即將在 MAC 中啟用 EEE。

int pcs_pre_init(struct phylink_pcs *pcs)¶: 配置 MAC 初始化所需的 PCS 元件

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標。

描述

此函式可以透過 phylink_pcs_pre_init() 包裝器由 MAC 驅動程式呼叫，在其硬體初始化之前。不應在鏈路啟動後呼叫它，因為此時重新配置 PCS 可能會中斷鏈路。

某些 MAC 裝置需要由其關聯的 PCS 裝置執行特定的硬體初始化，然後才能正確初始化其自己的硬體。一個例子是 stmmac 控制器的初始化，它需要 PHY/PCS 提供活動的 REF_CLK 訊號。

透過呼叫 phylink_pcs_pre_init()，MAC 驅動程式可以確保以允許成功進行硬體初始化的方式設定 PCS。

pcs_pre_init() 執行的特定配置取決於 PCS 的型號和連線到它的 MAC 裝置的要求。PCS 驅動程式作者應考慮他們的目標裝置是否將與驅動程式呼叫 phylink_pcs_pre_init() 的 MAC 裝置結合使用。MAC 驅動程式作者應記錄他們對 PCS 預初始化的要求。

int phylink_get_link_timer_ns(phy_interface_t interface)¶: 返回 PCS 鏈路計時器值

引數

phy_interface_t interface: 鏈路 typedef phy_interface_t 模式

描述

返回 PHY interface 模式的 PCS 鏈路計時器設定（以納秒為單位），如果適用，則返回 -EINVAL。

bool phylink_mac_implements_lpi(const struct phylink_mac_ops *ops)¶: 確定 MAC 是否實現 LPI 操作

引數

const struct phylink_mac_ops *ops: phylink_mac_ops 結構

描述

如果 phylink MAC 操作結構指示已實現 LPI 操作，則返回 true，否則返回 false。

struct phylink¶: phylink 的內部資料型別

定義:

struct phylink {
};

成員

void phylink_set_port_modes(unsigned long *mask)¶: 在 ethtool 掩碼中設定埠型別模式

引數

unsigned long *mask: ethtool 鏈路模式掩碼

描述

在 ethtool 掩碼中設定所有埠型別模式。MAC 驅動程式應在其“validate”回撥中使用此項。

int phylink_interface_max_speed(phy_interface_t interface)¶: 獲取 phy 介面的最大速度

引數

phy_interface_t interface: 由 typedef phy_interface_t 定義的 phy 介面模式

描述

確定 phy 介面的最大速度。這旨在幫助確定在 phy 執行速率匹配時要傳遞給 MAC 的正確速度。

返回 skb dst_entry

interface 的最大速度

unsigned long phylink_caps_to_link_caps(unsigned long caps)¶: 轉換一組 MAC 功能 LINK caps

引數

unsigned long caps: 一組 MAC 功能

返回 skb dst_entry

phy-caps.h 中定義的相應 LINK_CAPA 集

void phylink_caps_to_linkmodes(unsigned long *linkmodes, unsigned long caps)¶: 將功能轉換為 ethtool 鏈路模式

引數

unsigned long *linkmodes: ethtool 鏈路模式掩碼（必須已初始化）
unsigned long caps: MAC 功能的位掩碼

描述

在 linkmodes 中設定 caps 支援的所有可能的暫停、速度和雙工鏈路模式。 linkmodes 必須已事先初始化。

void phylink_limit_mac_speed(struct phylink_config *config, u32 max_speed)¶: 將 phylink_config 限制為最大速度

引數

struct phylink_config *config: 指向 struct phylink_config 的指標
u32 max_speed: 最大速度

描述

遮蔽速度高於 max_speed 引數的 MAC 功能。對 config.mac_capabilities 的任何進一步修改都將覆蓋此項。

unsigned long phylink_cap_from_speed_duplex(int speed, unsigned int duplex)¶: 從速度/雙工獲取 mac 功能

引數

int speed: 要搜尋的速度
unsigned int duplex: 要搜尋的雙工

描述

查詢給定速度和雙工的 mac 功能。

返回 skb dst_entry

具有 mac 功能修補 speed 和 duplex 的掩碼，如果: 沒有匹配項，則為 0。

unsigned long phylink_get_capabilities(phy_interface_t interface, unsigned long mac_capabilities, int rate_matching)¶: 獲取給定 MAC 的功能

引數

phy_interface_t interface: 由 typedef phy_interface_t 定義的 phy 介面模式
unsigned long mac_capabilities: MAC 功能的位掩碼
int rate_matching: 正在執行的速率匹配的型別

描述

獲取 interface 模式和 mac_capabilities 支援的 MAC 功能。

void phylink_validate_mask_caps(unsigned long *supported, struct phylink_link_state *state, unsigned long mac_capabilities)¶: 基於 caps 限制鏈路模式

引數

unsigned long *supported: 支援的鏈路模式的 ethtool 位掩碼。
struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。
unsigned long mac_capabilities: MAC 功能的位掩碼

描述

根據 mac_capabilities 計算支援的鏈路模式，並基於此限制 supported 和 state。如果您的功能不是恆定的（例如，如果它們因介面而異），請使用此函式。

void phylink_pcs_neg_mode(struct phylink *pl, struct phylink_pcs *pcs, phy_interface_t interface, const unsigned long *advertising)¶: 用於確定 PCS 帶內模式的幫助程式

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標
phy_interface_t interface: 要使用的介面模式
const unsigned long *advertising: 通告 ethtool 鏈路模式掩碼

描述

確定 PCS 要使用的協商模式，並返回以下模式之一

PHYLINK_PCS_NEG_NONE：介面模式不支援帶內
PHYLINK_PCS_NEG_OUTBAND：將使用帶外模式（例如，讀取 PHY）。
PHYLINK_PCS_NEG_INBAND_DISABLED：選擇了帶內模式，但停用了自動協商
PHYLINK_PCS_NEG_INBAND_ENABLED：選擇了帶內模式，並啟用了自動協商

注意

這適用於 PCS 本身參與協商的情況（例如，條款 37、SGMII 和類似條款），而不是條款 73。

int phylink_set_fixed_link(struct phylink *pl, const struct phylink_link_state *state)¶: 設定固定鏈路

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
const struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。

描述

當鏈路引數已知且不會更改時，使用此函式，使其適用於某些型別的網路連線。

返回 skb dst_entry

成功時為零，或為負錯誤程式碼。

struct phylink *phylink_create(struct phylink_config *config, const struct fwnode_handle *fwnode, phy_interface_t iface, const struct phylink_mac_ops *mac_ops)¶: 建立 phylink 例項

引數

struct phylink_config *config: 指向目標 struct phylink_config 的指標
const struct fwnode_handle *fwnode: 指向描述網路介面的 struct fwnode_handle 的指標
phy_interface_t iface: 由 typedef phy_interface_t 定義的所需鏈路模式
const struct phylink_mac_ops *mac_ops: 指向 MAC 的 struct phylink_mac_ops 的指標。

描述

建立一個新的 phylink 例項，並解析在 np 中找到的鏈路引數。這將解析帶內模式、固定鏈路或 SFP 配置。

返回指向 struct phylink 的指標，或一個錯誤指標值。使用者必須使用 IS_ERR() 檢查此函式中的錯誤。

注意

呼叫此函式時不得持有 rtnl 鎖。

void phylink_destroy(struct phylink *pl)¶: 清理並銷燬 phylink 例項

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

銷燬 phylink 例項。必須透過 phylink_disconnect_phy() 清理任何已連線的 PHY，然後再呼叫此函式。

注意

呼叫此函式時不得持有 rtnl 鎖。

bool phylink_expects_phy(struct phylink *pl)¶: 確定 phylink 是否需要連線 PHY

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

當使用固定鏈路模式，或帶內模式與 1000base-X 或 2500base-X 時，不需要 PHY。

如果 phylink 將需要 PHY，則返回 true。

int phylink_connect_phy(struct phylink *pl, struct phy_device *phy)¶: 將 PHY 連線到 phylink 例項

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct phy_device *phy: 指向 struct phy_device 的指標。

描述

透過呼叫 phy_attach_direct() 將 phy 連線到 pl 指定的 phylink 例項。根據 MAC 驅動程式的功能配置 phy，啟動 PHYLIB 狀態機，並啟用 PHY 支援的任何中斷。

這將更新 phylink 的 ethtool 支援和通告鏈路模式掩碼。

成功時返回 0，失敗時返回負的 errno。

int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn, u32 flags)¶: 連線 DT 模式中指定的 PHY。

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct device_node *dn: 指向 struct device_node 的指標。
u32 flags: PHY 特定的標誌，用於與 PHY 裝置驅動程式通訊

描述

將裝置節點 dn 中指定的 PHY 連線到 pl 指定的 phylink 例項。將執行 phylink_connect_phy() 中指定的操作。

成功時返回 0，失敗時返回負的 errno。

int phylink_fwnode_phy_connect(struct phylink *pl, const struct fwnode_handle *fwnode, u32 flags)¶: 連線 fwnode 中指定的 PHY。

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
const struct fwnode_handle *fwnode: 指向 struct fwnode_handle 的指標。
u32 flags: PHY 特定的標誌，用於與 PHY 裝置驅動程式通訊

描述

將 fwnode 中指定的 PHY 連線到 pl 指定的 phylink 例項。

成功時返回 0，失敗時返回負的 errno。

void phylink_disconnect_phy(struct phylink *pl)¶: 斷開連線到 phylink 例項的任何 PHY。

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

從 pl 描述的 phylink 例項斷開任何當前 PHY 的連線。

void phylink_mac_change(struct phylink *pl, bool up)¶: 通知 phylink MAC 狀態的變化

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
bool up: 指示鏈路當前是否已啟動。

描述

當 MAC 驅動程式的鏈路狀態發生變化時（例如，鏈路故障，新的協商結果等），應呼叫此驅動程式。

void phylink_pcs_change(struct phylink_pcs *pcs, bool up)¶: 通知 phylink PCS 鏈路狀態的變化

引數

struct phylink_pcs *pcs: 指向 struct phylink_pcs 的指標
bool up: 指示鏈路當前是否已啟動。

描述

當 PCS 驅動程式的鏈路狀態發生變化時（例如，鏈路故障，新的協商結果等），應呼叫此函式。注意：不應透過讀取 BMSR 來確定“up”。如果在中斷時對鏈路狀態有疑問，則當 pcs_get_state() 返回鎖定的鏈路斷開狀態時，傳遞 true，否則傳遞 false。

void phylink_start(struct phylink *pl)¶: 啟動一個 phylink 例項

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

啟動 pl 指定的 phylink 例項，配置 MAC 以用於所需的鏈路模式和協商樣式。應該從網路裝置驅動程式的 struct net_device_ops ndo_open() 方法中呼叫此函式。

void phylink_stop(struct phylink *pl)¶: 停止一個 phylink 例項

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

停止 pl 指定的 phylink 例項。應該從網路裝置驅動程式的 struct net_device_ops ndo_stop() 方法中呼叫此函式。呼叫此函式之前，不應更改網路裝置的載波狀態。

如果鏈路尚未斷開，這將同步斷開鏈路（換句話說，它將觸發 mac_link_down() 方法呼叫。）

void phylink_rx_clk_stop_block(struct phylink *pl)¶: 阻止 PHY 在 LPI 中停止接收時鐘

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

停用 PHY 在接收路徑處於 EEE LPI 狀態時停止接收時鐘的能力，直到對 phylink_rx_clk_stop_block() 的呼叫次數與對 phylink_rx_clk_stop_unblock() 的呼叫次數平衡為止。

void phylink_rx_clk_stop_unblock(struct phylink *pl)¶: 取消阻止 PHY 停止接收時鐘

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

對 phylink_rx_clk_stop_block() 的所有呼叫必須與對 phylink_rx_clk_stop_unblock() 的相應呼叫保持平衡，以恢復 PHY 在接收路徑處於 EEE LPI 模式時停止接收時鐘的能力。

void phylink_suspend(struct phylink *pl, bool mac_wol)¶: 處理網路裝置掛起事件

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
bool mac_wol: 如果 MAC 需要接收區域網喚醒的資料包，則為 true

描述

處理網路裝置掛起事件。有幾種情況

如果區域網喚醒未啟用，我們可以透過呼叫 phylink_stop() 來關閉 MAC 和 PHY 之間的鏈路。
如果區域網喚醒處於活動狀態，並且僅由 PHY 處理，我們也可以關閉 MAC 和 PHY 之間的鏈路。
如果區域網喚醒處於活動狀態，但由 MAC 處理，則 MAC 仍然需要接收資料包，因此我們不能關閉鏈路。

void phylink_prepare_resume(struct phylink *pl)¶: 準備恢復網路裝置

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

可選，但如果呼叫，則必須在 phylink_resume() 之前呼叫。

準備恢復網路裝置，根據需要準備 PHY。

void phylink_resume(struct phylink *pl)¶: 處理網路裝置恢復事件

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

撤消 phylink_suspend() 的影響，使鏈路恢復到可操作狀態。

void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol)¶: 獲取 PHY 的區域網喚醒引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_wolinfo *wol: 指向 struct ethtool_wolinfo 的指標，用於儲存讀取的引數

描述

從 pl 指定的 phylink 例項連線的 PHY 讀取區域網喚醒引數。如果當前未連線 PHY，則報告不支援區域網喚醒。

int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol)¶: 設定區域網喚醒引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_wolinfo *wol: 指向 struct ethtool_wolinfo 的指標，用於所需的引數

描述

為連線到 pl 指定的 phylink 例項的 PHY 設定區域網喚醒引數。如果未連線 PHY，則返回 EOPNOTSUPP 錯誤。

成功時返回零，失敗時返回負的 errno 程式碼。

int phylink_ethtool_ksettings_get(struct phylink *pl, struct ethtool_link_ksettings *kset)¶: 獲取當前鏈路設定

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_link_ksettings *kset: 指向 struct ethtool_link_ksettings 的指標，用於儲存鏈路設定

描述

讀取 pl 指定的 phylink 例項的當前鏈路設定。這將是從 MAC、PHY 或固定鏈路設定讀取的鏈路設定，具體取決於當前的協商模式。

int phylink_ethtool_ksettings_set(struct phylink *pl, const struct ethtool_link_ksettings *kset)¶: 設定鏈路設定

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
const struct ethtool_link_ksettings *kset: 指向 struct ethtool_link_ksettings 的指標，用於所需的模式

int phylink_ethtool_nway_reset(struct phylink *pl)¶: 重新啟動協商

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

重新啟動 pl 指定的 phylink 例項的協商。這將導致任何連線的 PHY 重新啟動與鏈路夥伴的協商，並且如果 MAC 處於 BaseX 模式，也將請求 MAC 重新啟動協商。

成功時返回零，或者返回負的錯誤程式碼。

void phylink_ethtool_get_pauseparam(struct phylink *pl, struct ethtool_pauseparam *pause)¶: 獲取當前的暫停引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_pauseparam *pause: 指向 struct ethtool_pauseparam 的指標

int phylink_ethtool_set_pauseparam(struct phylink *pl, struct ethtool_pauseparam *pause)¶: 設定當前的暫停引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_pauseparam *pause: 指向 struct ethtool_pauseparam 的指標

int phylink_get_eee_err(struct phylink *pl)¶: 讀取節能乙太網錯誤計數器

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標。

描述

從與 pl 指定的 phylink 例項關聯的 PHY 讀取節能乙太網錯誤計數器。

返回正錯誤計數器值，或者返回負錯誤程式碼。

int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_keee *eee)¶: 讀取節能乙太網引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_keee *eee: 指向 struct ethtool_keee 的指標，用於讀取的引數

int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_keee *eee)¶: 設定節能乙太網引數

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ethtool_keee *eee: 指向 struct ethtool_keee 的指標，用於所需的引數

int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)¶: 通用 mii ioctl 介面

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
struct ifreq *ifr: 指向 struct ifreq 的指標，用於套接字 ioctls
int cmd: 要執行的 ioctl cmd

描述

在連線到 pl 指定的 phylink 例項的 PHY 上執行指定的 MII ioctl。如果未連線 PHY，則模擬 PHY 的存在。

SIOCGMIIPHY:: 從當前 PHY 讀取暫存器。
SIOCGMIIREG:: 從指定的 PHY 讀取暫存器。
SIOCSMIIREG:: 設定指定 PHY 上的暫存器。

返回 skb dst_entry

成功時為零，或為負錯誤程式碼。

int phylink_speed_down(struct phylink *pl, bool sync)¶: 將非 SFP PHY 設定為鏈路夥伴都支援的最低速度

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標
bool sync: 同步執行操作

描述

如果我們有一個不屬於 SFP 模組的 PHY，則按照 phy_speed_down() 函式中的描述設定速度。請參閱此函式以獲取 sync 引數的描述。

如果不存在 PHY，則返回零，否則按照 phy_speed_down() 中的描述返回。

int phylink_speed_up(struct phylink *pl)¶: 恢復呼叫 phylink_speed_down() 之前的通告速度

引數

struct phylink *pl: 指向從 phylink_create() 返回的 struct phylink 的指標

描述

如果我們有一個不屬於 SFP 模組的 PHY，則按照 phy_speed_up() 恢復 PHY 速度。

如果不存在 PHY，則返回零，否則按照 phy_speed_up() 中的描述返回。

void phylink_decode_usxgmii_word(struct phylink_link_state *state, uint16_t lpa)¶: 從 MAC PCS 解碼 USXGMII 字

引數

struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。
uint16_t lpa: 儲存 USXGMII 自動協商字的 16 位值

描述

適用於支援 USXGMII 協議和自動協商程式碼字的 MAC PCS。解碼 USXGMII 程式碼字並將相應的欄位（速度，雙工）填充到 phylink_link_state 結構中。

void phylink_decode_usgmii_word(struct phylink_link_state *state, uint16_t lpa)¶: 從 MAC PCS 解碼 USGMII 字

引數

struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。
uint16_t lpa: 儲存 USGMII 自動協商字的 16 位值

描述

適用於支援 USGMII 協議和自動協商程式碼字的 MAC PCS。解碼 USGMII 程式碼字並將相應的欄位（速度，雙工）填充到 phylink_link_state 結構中。此字的結構與 USXGMII 字相同，只是它僅支援高達 1Gbps 的速度。

void phylink_mii_c22_pcs_decode_state(struct phylink_link_state *state, unsigned int neg_mode, u16 bmsr, u16 lpa)¶: 從 MII 暫存器解碼 MAC PCS 狀態

引數

struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。
unsigned int neg_mode: 鏈路協商模式 (PHYLINK_PCS_NEG_xxx)
u16 bmsr: MII_BMSR 暫存器的值
u16 lpa: MII_LPA 暫存器的值

描述

適用於支援 802.3 clause 22 暫存器集以用於 clause 37 協商和/或 SGMII 控制的 MAC PCS。

將 Clause 37 或 Cisco SGMII 鏈路夥伴協商字解析到 phylink state 結構中。這適用於用於實現 pcs_get_state() 的 struct phylink_pcs_ops 結構的成員，如果無法直接透過 MDIO 訪問 bmsr 和 lpa 。

void phylink_mii_c22_pcs_get_state(struct mdio_device *pcs, unsigned int neg_mode, struct phylink_link_state *state)¶: 讀取 MAC PCS 狀態

引數

struct mdio_device *pcs: 指向 struct mdio_device 的指標。
unsigned int neg_mode: 鏈路協商模式 (PHYLINK_PCS_NEG_xxx)
struct phylink_link_state *state: 指向 struct phylink_link_state 的指標。

描述

適用於支援 802.3 clause 22 暫存器集以用於 clause 37 協商和/或 SGMII 控制的 MAC PCS。

從 config 中配置的 MII 裝置讀取 MAC PCS 狀態，並將 Clause 37 或 Cisco SGMII 鏈路夥伴協商字解析到 phylink state 結構中。這適用於直接插入到 pcs_get_state() 的 struct phylink_pcs_ops 結構的成員。

int phylink_mii_c22_pcs_encode_advertisement(phy_interface_t interface, const unsigned long *advertising)¶: 配置 clause 37 PCS 廣播

引數

phy_interface_t interface: 正在配置的 PHY 介面模式
const unsigned long *advertising: ethtool 廣播掩碼

描述

適用於支援 802.3 clause 22 暫存器集以用於 clause 37 協商和/或 SGMII 控制的 MAC PCS。

根據 interface 和 advertising 指定的編碼 clause 37 PCS 廣播。

返回 skb dst_entry

adv 的新值，如果應保持不變則為 -EINVAL。

int phylink_mii_c22_pcs_config(struct mdio_device *pcs, phy_interface_t interface, const unsigned long *advertising, unsigned int neg_mode)¶: 配置 clause 22 PCS

引數

struct mdio_device *pcs: 指向 struct mdio_device 的指標。
phy_interface_t interface: 正在配置的 PHY 介面模式
const unsigned long *advertising: ethtool 廣播掩碼
unsigned int neg_mode: PCS 協商模式

描述

使用適用於 mode、interface 和 advertising 引數的適當協商引數來配置 Clause 22 PCS PHY。失敗時返回負錯誤號，如果廣播未更改則返回零，如果發生更改則返回正數。

void phylink_mii_c22_pcs_an_restart(struct mdio_device *pcs)¶: 重啟 802.3z 自協商

引數

struct mdio_device *pcs: 指向 struct mdio_device 的指標。

描述

用於支援 802.3 clause 22 暫存器集（用於 clause 37 協商）的 MAC PCS 的助手函式。

與鏈路夥伴重啟 clause 37 協商。這適合直接插入到 pcs_get_state() 的 struct phylink_pcs_ops 成員中。

SFP 支援¶

struct sfp_bus¶: sfp 匯流排的內部表示

定義:

struct sfp_bus {
};

成員

struct sfp_eeprom_id¶: 原始 SFP 模組識別資訊

定義:

struct sfp_eeprom_id {
    struct sfp_eeprom_base base;
    struct sfp_eeprom_ext ext;
};

成員

base: 基本 SFP 模組識別結構
ext: 擴充套件 SFP 模組識別結構

描述

有關這些結構成員的定義，請參閱 SFF-8472 規範和相關文件。可以從 https://www.snia.org/technology-communities/sff/specifications 獲取

struct sfp_upstream_ops¶: 上游操作結構

定義:

struct sfp_upstream_ops {
    void (*attach)(void *priv, struct sfp_bus *bus);
    void (*detach)(void *priv, struct sfp_bus *bus);
    int (*module_insert)(void *priv, const struct sfp_eeprom_id *id);
    void (*module_remove)(void *priv);
    int (*module_start)(void *priv);
    void (*module_stop)(void *priv);
    void (*link_down)(void *priv);
    void (*link_up)(void *priv);
    int (*connect_phy)(void *priv, struct phy_device *);
    void (*disconnect_phy)(void *priv, struct phy_device *);
};

成員

attach: 當 sfp 套接字驅動程式繫結到上游時呼叫（強制性）。
detach: 當 sfp 套接字驅動程式從上游解除繫結時呼叫（強制性）。
module_insert: 在檢測到模組後呼叫，以確定上游裝置是否支援該模組。
module_remove: 在模組已移除後呼叫。
module_start: 在 PHY 探測步驟之後呼叫
module_stop: 在移除 PHY 之前呼叫
link_down: 當鏈路由於任何原因而無法執行時呼叫。
link_up: 當鏈路執行時呼叫。
connect_phy: 當在模組上檢測到 I2C 可訪問 PHY 時呼叫。
disconnect_phy: 當移除具有 I2C 可訪問 PHY 的模組時呼叫。

int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id, unsigned long *support)¶: 解析 EEPROM 基本 ID，設定埠型別

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
const struct sfp_eeprom_id *id: 指向模組 struct sfp_eeprom_id 的指標
unsigned long *support: 指向 ethtool 支援掩碼的無符號長整型陣列的可選指標

描述

解析 id 中給出的 EEPROM 標識，並返回 PORT_TP、PORT_FIBRE 或 PORT_OTHER 之一。如果 support 不是 NULL，則還設定與聯結器型別對應的 ethtool ETHTOOL_LINK_MODE_xxx_BIT。

如果埠型別未知，則返回 PORT_OTHER。

bool sfp_may_have_phy(struct sfp_bus *bus, const struct sfp_eeprom_id *id)¶: 指示模組是否可能有 PHY

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
const struct sfp_eeprom_id *id: 指向模組 struct sfp_eeprom_id 的指標

描述

解析 id 中給出的 EEPROM 標識，並返回此模組是否可能有 PHY。

void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id, unsigned long *support, unsigned long *interfaces)¶: 解析 eeprom id 以獲取支援的鏈路模式

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
const struct sfp_eeprom_id *id: 指向模組 struct sfp_eeprom_id 的指標
unsigned long *support: 指向 ethtool 支援掩碼的無符號長整型陣列的指標
unsigned long *interfaces: 指向 phy 介面模式掩碼的無符號長整型陣列的指標

描述

解析 EEPROM 標識資訊並派生模組支援的 ethtool 鏈路模式。

phy_interface_t sfp_select_interface(struct sfp_bus *bus, const unsigned long *link_modes)¶: 選擇合適的 phy_interface_t 模式

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
const unsigned long *link_modes: ethtool 鏈路模式掩碼

描述

從鏈路模式掩碼派生 SFP 模組的 phy_interface_t 模式。

void sfp_bus_put(struct sfp_bus *bus)¶: 對 struct sfp_bus 放置引用

引數

struct sfp_bus *bus: 透過 sfp_bus_find_fwnode() 找到的 struct sfp_bus

描述

對 struct sfp_bus 放置引用，如果這是最後一個引用，則釋放底層結構。

int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo)¶: 獲取 SFP 模組的 ethtool_modinfo

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
struct ethtool_modinfo *modinfo: 一個 struct ethtool_modinfo

描述

在 modinfo 中填寫型別和 eeprom_len 引數，用於 bus 指定的 sfp 總線上的模組。

成功時返回 0，失敗時返回負 errno 號。

int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee, u8 *data)¶: 讀取 SFP 模組 EEPROM

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
struct ethtool_eeprom *ee: 一個 struct ethtool_eeprom
u8 *data: 用於包含 EEPROM 資料的緩衝區（必須至少為 ee->len 位元組）

描述

讀取 ee 指定的 EEPROM。有關要讀取的區域，請參閱 struct ethtool_eeprom 的文件。

成功時返回 0，失敗時返回負 errno 號。

int sfp_get_module_eeprom_by_page(struct sfp_bus *bus, const struct ethtool_module_eeprom *page, struct netlink_ext_ack *extack)¶: 從 SFP 模組 EEPROM 讀取頁面

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
const struct ethtool_module_eeprom *page: 一個 struct ethtool_module_eeprom
struct netlink_ext_ack *extack: 用於報告問題的 extack

描述

讀取 page 指定的 EEPROM 頁面。有關要讀取的頁面，請參閱 struct ethtool_module_eeprom 的文件。

成功時返回 0，失敗時返回負 errno 號。可能會透過 extack 提供更多錯誤資訊

void sfp_upstream_start(struct sfp_bus *bus)¶: 通知 SFP 網路裝置已啟動

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標

描述

通知 SFP 套接字網路裝置現在已啟動，以便可以透過取消斷言 TX_DISABLE 來啟用模組。應該從網路裝置驅動程式的 struct net_device_ops ndo_open() 方法呼叫此方法。

void sfp_upstream_stop(struct sfp_bus *bus)¶: 通知 SFP 網路裝置已關閉

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標

描述

通知 SFP 套接字網路裝置現在已啟動，以便可以透過斷言 TX_DISABLE（停用光模組中的雷射）來停用模組。應該從網路裝置驅動程式的 struct net_device_ops ndo_stop() 方法呼叫此方法。

void sfp_upstream_set_signal_rate(struct sfp_bus *bus, unsigned int rate_kbd)¶: 設定資料信令速率

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標
unsigned int rate_kbd: 以 1000 波特為單位的信令速率

描述

配置 SFP 模組上用於信令速率（與資料速率不同）的速率選擇設定。

可能持有的鎖: Phylink 的 state_mutex rtnl 鎖 SFP 的 sm_mutex

struct sfp_bus *sfp_bus_find_fwnode(const struct fwnode_handle *fwnode)¶: 從 fwnode 解析並定位 SFP 匯流排

引數

const struct fwnode_handle *fwnode: 父裝置（MAC 或 PHY）的韌體節點

描述

為 SFP 匯流排解析父裝置的韌體節點，並定位 sfp_bus 結構，遞增其引用計數。完成後，必須透過 sfp_bus_put() 放置。

返回 skb dst_entry

成功時，指向 sfp_bus 結構的指標，

如果未指定 SFP，則為 NULL，

失敗時，錯誤指標值

對應於 fwnode_property_get_reference_args() 詳細描述的錯誤。

如果我們未能分配匯流排，則為 -ENOMEM。

來自上游 connect_phy() 方法的錯誤。

int sfp_bus_add_upstream(struct sfp_bus *bus, void *upstream, const struct sfp_upstream_ops *ops)¶: 解析並註冊相鄰裝置

引數

struct sfp_bus *bus: 透過 sfp_bus_find_fwnode() 找到的 struct sfp_bus
void *upstream: 上游私有資料
const struct sfp_upstream_ops *ops: 上游的 struct sfp_upstream_ops

描述

為 SFP 匯流排新增上游驅動程式，如果匯流排已完成，則使用 sfp_register_upstream() 註冊 SFP 匯流排。這將在總線上放置引用，因此在此呼叫之後放置匯流排是安全的。

返回 skb dst_entry

成功時，指向 sfp_bus 結構的指標，

如果未指定 SFP，則為 NULL，

失敗時，錯誤指標值

對應於 fwnode_property_get_reference_args() 詳細描述的錯誤。

如果我們未能分配匯流排，則為 -ENOMEM。

來自上游 connect_phy() 方法的錯誤。

void sfp_bus_del_upstream(struct sfp_bus *bus)¶: 刪除 sfp 匯流排

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標

描述

刪除 SFP 模組的先前註冊的上游連線。應該透過 sfp_bus_add_upstream() 新增 bus。

const char *sfp_get_name(struct sfp_bus *bus)¶: 獲取 SFP 裝置名稱

引數

struct sfp_bus *bus: 指向 sfp 模組的 struct sfp_bus 結構的指標

描述

獲取 SFP 裝置的名稱，如果 bus 具有已註冊的套接字。呼叫者必須持有 RTNL，並且返回的名稱僅在釋放 RTNL 之前有效。

返回 skb dst_entry

使用 sfp_register_socket() 註冊的 SFP 裝置的名稱

如果 bus 上未註冊任何裝置，則為 NULL

Linux 核心

目錄

本頁

Linux 網路和網路裝置 API¶

Linux 網路¶

網路基本型別¶

套接字緩衝區函式¶

套接字過濾器¶

通用網路統計資訊¶

SUN RPC 子系統¶

網路裝置支援¶

驅動程式支援¶

PHY 支援¶

PHYLINK¶

SFP 支援¶