Linux 内核 TIPC

简介

TIPC（透明进程间通信）是一种专门为集群内通信设计的协议。它可以配置为通过 UDP 或直接通过以太网传输消息。消息传递保证顺序、无损且流量受控。延迟时间比任何其他已知协议都短，而最大吞吐量与 TCP 的吞吐量相当。

TIPC 特性

  • 集群范围的 IPC 服务

    您是否曾经希望即使在集群节点之间传输数据时也能方便地使用 Unix 域套接字？在其中，您可以自己确定要绑定和使用的地址？无需执行 DNS 查找并担心 IP 地址？无需启动计时器来监视对等套接字的持续存在？并且没有该套接字类型的缺点，例如残留 inode 的风险？

    欢迎使用透明进程间通信服务，简称 TIPC，它为您提供所有这些以及更多功能。

  • 服务寻址

    TIPC 的一个基本概念是服务寻址，它使程序员可以选择自己的地址，将其绑定到服务器套接字，并让客户端程序仅使用该地址发送消息。

  • 服务跟踪

    想要等待服务器可用的客户端，使用服务跟踪机制来订阅具有相关服务地址的套接字的绑定和取消绑定/关闭事件。

    服务跟踪机制还可用于集群拓扑跟踪，即订阅集群节点的可用性/不可用性。

    同样，服务跟踪机制还可用于集群连接跟踪，即订阅集群节点之间各个链路的启动/关闭事件。

  • 传输模式

    使用服务地址，客户端可以向服务器套接字发送数据报消息。

    使用相同的地址类型，它可以建立与接受服务器套接字的连接。

    它还可以使用服务地址来创建并加入通信组，这是 TIPC 的无代理消息总线的表现形式。

    在数据报模式和通信组模式下都提供性能和可扩展性都非常好的多播。

  • 节点间链路

    集群中任何两个节点之间的通信都由一个或两个节点间链路维护，这两个链路都保证数据流量的完整性并监视对等节点的可用性。

  • 集群可扩展性

    通过在节点间链路上应用重叠环监控算法，可以将 TIPC 集群扩展到 1000 个节点，并保持 1-2 秒的邻居故障发现时间。对于较小的集群，此时间可以缩短很多。

  • 邻居发现

    当任何这些服务可用时，集群中的邻居节点发现通过以太网广播或 UDP 多播完成。如果不可用，则可以使用配置的对等 IP 地址。

  • 配置

    在单节点模式下运行 TIPC 时，不需要任何配置。在集群模式下运行时，TIPC 必须至少给定一个节点地址（在 Linux 4.17 之前）并告知要附加的接口。“tipc” 配置工具可以添加和维护更多的配置参数。

  • 性能

    TIPC 消息传输延迟时间优于任何其他已知协议。节点间连接的最大字节吞吐量仍然略低于 TCP，而在同一主机上的节点内和容器间吞吐量方面则更胜一筹。

  • 语言支持

    TIPC 用户 API 支持 C、Python、Perl、Ruby、D 和 Go。

更多信息

实现

TIPC 作为 net/tipc/ 目录中的内核模块实现。

TIPC 基本类型

struct tipc_subscription

TIPC 网络拓扑订阅对象

定义:

struct tipc_subscription {
    struct tipc_subscr s;
    struct tipc_event evt;
    struct kref kref;
    struct net *net;
    struct timer_list timer;
    struct list_head service_list;
    struct list_head sub_list;
    int conid;
    bool inactive;
    spinlock_t lock;
};

成员

s

用户订阅的主机字节序副本

evt

订阅生成的事件模板

kref

此订阅的引用计数

net

与订阅关联的网络命名空间

timer

控制订阅持续时间的计时器（可选）

service_list

名称序列订阅列表中的相邻订阅

sub_list

订阅者的订阅列表中的相邻订阅

conid

拓扑服务器的连接标识符

inactive

如果此订阅处于非活动状态，则为 true

lock

序列化启动/关闭和计时器事件

struct tipc_media_addr

TIPC 承载使用的目标地址

定义:

struct tipc_media_addr {
    u8 value[TIPC_MEDIA_INFO_SIZE];
    u8 media_id;
    u8 broadcast;
};

成员

value

地址信息（格式由媒体定义）

media_id

TIPC 媒体类型标识符

broadcast

如果地址是广播地址，则为非零值

struct tipc_media

暴露给通用承载层的媒体特定信息

定义:

struct tipc_media {
    int (*send_msg)(struct net *net, struct sk_buff *buf,struct tipc_bearer *b, struct tipc_media_addr *dest);
    int (*enable_media)(struct net *net, struct tipc_bearer *b, struct nlattr *attr[]);
    void (*disable_media)(struct tipc_bearer *b);
    int (*addr2str)(struct tipc_media_addr *addr,char *strbuf, int bufsz);
    int (*addr2msg)(char *msg, struct tipc_media_addr *addr);
    int (*msg2addr)(struct tipc_bearer *b,struct tipc_media_addr *addr, char *msg);
    int (*raw2addr)(struct tipc_bearer *b,struct tipc_media_addr *addr, const char *raw);
    u32 priority;
    u32 tolerance;
    u32 min_win;
    u32 max_win;
    u32 mtu;
    u32 type_id;
    u32 hwaddr_len;
    char name[TIPC_MAX_MEDIA_NAME];
};

成员

send_msg

处理缓冲区传输的例程

enable_media

启用媒体的例程

disable_media

禁用媒体的例程

addr2str

将媒体地址格式转换为字符串

addr2msg

将媒体地址格式转换为发现消息地址格式

msg2addr

将发现消息地址格式转换为媒体地址格式

raw2addr

将原始地址格式转换为媒体地址格式

priority

默认链路（和承载）优先级

tolerance

声明链路故障之前的默认时间（以毫秒为单位）

min_win

声明链路拥塞之前的最小窗口（以数据包为单位）

max_win

声明链路拥塞之前的最大窗口（以数据包为单位）

mtu

承载可以支持的最大数据包大小，该大小与底层设备 MTU 无关

type_id

TIPC 媒体标识符

hwaddr_len

TIPC 媒体地址长度

name

媒体名称

struct tipc_bearer

通用 TIPC 承载结构

定义:

struct tipc_bearer {
    void __rcu *media_ptr;
    u32 mtu;
    struct tipc_media_addr addr;
    char name[TIPC_MAX_BEARER_NAME];
    struct tipc_media *media;
    struct tipc_media_addr bcast_addr;
    struct packet_type pt;
    struct rcu_head rcu;
    u32 priority;
    u32 min_win;
    u32 max_win;
    u32 tolerance;
    u32 domain;
    u32 identity;
    struct tipc_discoverer *disc;
    char net_plane;
    u16 encap_hlen;
    unsigned long up;
    refcount_t refcnt;
};

成员

media_ptr

指向有关承载的特定于媒体的其他信息的指针

mtu

承载可以支持的最大数据包大小

addr

与承载关联的特定于媒体的地址

name

承载名称 (格式 = media:interface)

media

指向与承载关联的媒体结构的指针

bcast_addr

广播中使用的媒体地址

pt

承载的数据包类型

rcu

tipc_bearer 的 rcu 结构

priority

承载的默认链路优先级

min_win

声明链路拥塞之前的最小窗口（以数据包为单位）

max_win

声明链路拥塞之前的最大窗口（以数据包为单位）

tolerance

承载的默认链路容差

domain

可以建立链路的网络域

identity

此承载在 TIPC 承载数组中的数组索引

disc

指向链路设置请求的指针

net_plane

当前与承载关联的网络平面（“A”到“H”）

encap_hlen

封装标头长度

up

承载启动标志（位 0）

refcnt

tipc_bearer 引用计数器

注意

当启用承载时，特定于媒体的代码负责初始化下面指示的字段；TIPC 的通用承载代码负责初始化所有其他字段。

struct publication

有关已发布的服务地址或范围的信息

定义:

struct publication {
    struct tipc_service_range sr;
    struct tipc_socket_addr sk;
    u16 scope;
    u32 key;
    u32 id;
    struct list_head binding_node;
    struct list_head binding_sock;
    struct list_head local_publ;
    struct list_head all_publ;
    struct list_head list;
    struct rcu_head rcu;
};

成员

sr

此发布表示的服务范围

sk

绑定到此发布的套接字的地址

scope

发布范围，TIPC_NODE_SCOPE 或 TIPC_CLUSTER_SCOPE

key

发布密钥，在集群中唯一

id

发布 ID

binding_node

所有来自绑定此节点的同一节点的所有发布 - 远程发布：在 node->publ_list 中；当节点丢失时，节点/名称分布用于撤回发布 - 本地/节点范围发布：在 name_table->node_scope 列表中 - 本地/集群范围发布：在 name_table->cluster_scope 列表中

binding_sock

来自绑定此套接字的所有发布。当套接字解除绑定/释放时，套接字用于撤回发布

local_publ

从此节点发出的相同发布的列表。由 closest_first 和多播接收查找算法使用

all_publ

与此相同的所有发布，无论节点和范围如何。由轮询查找算法使用

list

以时间顺序形成发布列表

rcu

用于延迟释放的 RCU 回调头

struct name_table

包含所有现有端口名称发布的表

定义:

struct name_table {
    struct hlist_head services[TIPC_NAMETBL_SIZE];
    struct list_head node_scope;
    struct list_head cluster_scope;
    rwlock_t cluster_scope_lock;
    u32 local_publ_count;
    u32 rc_dests;
    u32 snd_nxt;
};

成员

services

名称序列哈希列表

node_scope

所有具有节点范围的本地发布 - 在名称表重新初始化期间由 name_distr 使用

cluster_scope

所有具有集群范围的本地发布 - 由 name_distr 用于向新节点发送批量更新 - 在名称表重新初始化期间由 name_distr 使用

cluster_scope_lock

用于访问 cluster_scope 的锁

local_publ_count

此节点发出的发布数量

rc_dests

目标节点计数器

snd_nxt

要使用的下一个序列号

struct distr_item

发布信息分发到其他节点

定义:

struct distr_item {
    __be32 type;
    __be32 lower;
    __be32 upper;
    __be32 port;
    __be32 key;
};

成员

type

名称序列类型

lower

名称序列下限

upper

名称序列上限

port

发布端口引用

key

publication key

描述

===>所有字段都以网络字节顺序存储。<===

前 3 个字段标识正在发布的（名称或）名称序列。引用字段唯一标识发布名称序列的端口。密钥字段唯一标识发布，以防端口具有相同名称序列的多个发布。

注意

没有标识发布节点的字段，因为它对于发布消息中包含的所有项目都是相同的。

struct tipc_bc_base

用于保持广播发送状态的基本结构

定义:

struct tipc_bc_base {
    struct tipc_link *link;
    struct sk_buff_head inputq;
    int dests[MAX_BEARERS];
    int primary_bearer;
    bool bcast_support;
    bool force_bcast;
    bool rcast_support;
    bool force_rcast;
    int rc_ratio;
    int bc_threshold;
};

成员

link

广播发送链接结构

inputq

数据输入队列；将只携带 SOCK_WAKEUP 消息

dests

保存每个承载可达目标数量的数组

primary_bearer

如果有，则具有到所有广播目标的链接的承载

bcast_support

指示主承载（如果有）是否支持广播

force_bcast

强制多播流量进行广播

rcast_support

指示所有对等节点是否支持复制广播

force_rcast

强制多播流量进行复制广播

rc_ratio

目标计数占集群大小的百分比，其中发送方法发生变化

bc_threshold

从 rc_ratio 计算；如果 dests > 阈值，则使用广播

TIPC 承载接口

struct tipc_media *tipc_media_find(const char *name)

按名称查找指定的媒体对象

参数

const char *name

要查找的名称

struct tipc_media *media_find_id(u8 type)

按类型标识符查找指定的媒体对象

参数

u8 type

要查找的类型标识符

int tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)

在打印缓冲区中记录媒体地址

参数

char *buf

输出缓冲区

int len

剩余输出缓冲区大小

struct tipc_media_addr *a

输入媒体地址

int bearer_name_validate(const char *name, struct tipc_bearer_names *name_parts)

验证和（可选）解构承载名称

参数

const char *name

指向承载名称字符串的指针

struct tipc_bearer_names *name_parts

指向承载名称组件区域的指针（如果不需要，则为 NULL）

返回

如果承载名称有效，则为 1，否则为 0。

struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)

查找具有匹配承载名称的承载对象

参数

struct net *net

适用的 net 命名空间

const char *name

要查找的承载名称

int tipc_enable_bearer(struct net *net, const char *name, u32 disc_domain, u32 prio, struct nlattr *attr[], struct netlink_ext_ack *extack)

使用给定名称启用承载

参数

struct net *net

适用的 net 命名空间

const char *name

要启用的承载名称

u32 disc_domain

承载域

u32 prio

承载优先级

struct nlattr *attr[]

nlattr 数组

struct netlink_ext_ack *extack

netlink 扩展确认

int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)

重置通过此承载建立的所有链接

参数

struct net *net

适用的 net 命名空间

struct tipc_bearer *b

目标承载

void bearer_disable(struct net *net, struct tipc_bearer *b)

禁用此承载。

参数

struct net *net

适用的 net 命名空间

struct tipc_bearer *b

要禁用的承载。

注意

此例程假定调用者持有 RTNL 锁。

int tipc_l2_send_msg(struct net *net, struct sk_buff *skb, struct tipc_bearer *b, struct tipc_media_addr *dest)

通过 L2 接口发送一个 TIPC 数据包。

参数

struct net *net

关联的网络命名空间。

struct sk_buff *skb

要发送的数据包。

struct tipc_bearer *b

要通过其发送数据包的承载。

struct tipc_media_addr *dest

对等目标地址。

int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)

处理来自接口的传入 TIPC 消息。

参数

struct sk_buff *skb

接收到的消息。

struct net_device *dev

接收到数据包的网络设备。

struct packet_type *pt

用于注册此处理程序的 packet_type 结构。

struct net_device *orig_dev

如果设备是绑定设备，则为原始接收网络设备。

描述

仅接受显式发送到此节点或广播数据包的数据包；忽略使用接口多播发送的数据包，以及发送到其他节点的流量（如果接口以混杂模式运行，则可能发生这种情况）。

int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt, void *ptr)

处理来自网络设备的设备事件。

参数

struct notifier_block *nb

通知的上下文。

unsigned long evt

事件的类型。

void *ptr

发生事件的网络设备。

描述

在链路更改事件的情况下，此函数由以太网驱动程序调用。

struct udp_media_addr

IP/UDP 寻址信息。

定义:

struct udp_media_addr {
    __be16 proto;
    __be16 port;
    union {
        struct in_addr ipv4;
        struct in6_addr ipv6;
    };
};

成员

协议。

正在使用的以太网协议。

port

正在使用的端口。

{未命名联合}

匿名。

ipv4

邻居的 IPv4 地址。

ipv6

邻居的 IPv6 地址。

描述

这是邻居发现消息中使用的承载级始发地址，所有字段都应采用网络字节序。

struct udp_bearer

ip/udp 承载数据结构。

定义:

struct udp_bearer {
    struct tipc_bearer __rcu *bearer;
    struct socket *ubsock;
    u32 ifindex;
    struct work_struct work;
    struct udp_replicast rcast;
};

成员

承载。

关联的通用 tipc 承载。

ubsock

承载关联的套接字。

ifindex

本地地址范围。

工作。

用于在承载上调度延迟工作。

rcast

关联的 udp_replicast 容器。

int tipc_parse_udp_addr(struct nlattr *nla, struct udp_media_addr *addr, u32 *scope_id)

从 netlink 数据构建 udp 媒体地址。

参数

struct nlattr *nla

包含 sockaddr 存储对齐地址的 netlink 属性。

struct udp_media_addr *addr

要填充地址、端口和协议类型的 tipc 媒体地址。

u32 *scope_id

IPv6 范围 ID 指针，非 NULL 表示它是必需的。

int tipc_udp_enable(struct net *net, struct tipc_bearer *b, struct nlattr *attrs[])

用于创建新的 udp 承载实例的回调。

参数

struct net *net

网络命名空间。

struct tipc_bearer *b

指向通用 tipc_bearer 的指针。

struct nlattr *attrs[]

netlink 承载配置。

描述

验证承载参数并初始化 udp 承载，应持有 rtnl_lock。

TIPC 加密接口

struct tipc_tfm

用于形成 TFM 列表的 TIPC TFM 结构。

定义:

struct tipc_tfm {
    struct crypto_aead *tfm;
    struct list_head list;
};

成员

tfm

密码句柄/密钥。

list

TFM 的链表。

struct tipc_aead

TIPC AEAD 密钥结构。

定义:

struct tipc_aead {
#define TIPC_AEAD_HINT_LEN (5);
    struct tipc_tfm * __percpu *tfm_entry;
    struct tipc_crypto *crypto;
    struct tipc_aead *cloned;
    atomic_t users;
    u32 salt;
    u8 authsize;
    u8 mode;
    char hint[2 * TIPC_AEAD_HINT_LEN + 1];
    struct rcu_head rcu;
    struct tipc_aead_key *key;
    u16 gen;
    atomic64_t seqno ;
    refcount_t refcnt ;
};

成员

tfm_entry

指向 TFM 列表中一个条目的每个 CPU 指针。

加密。

TIPC 加密拥有此密钥。

已克隆。

克隆时引用源密钥。

用户。

密钥用户数 (TX/RX)。

盐。

密钥的 SALT 值。

authsize

身份验证标记大小（最大 = 16）。

模式。

加密模式应用于密钥。

提示。

用户密钥的提示。

rcu

struct rcu_head

key

aead 密钥。

gen

密钥的生成。

seqno

密钥序列号（集群范围）。

refcnt

密钥引用计数器。

struct tipc_crypto_stats

TIPC 加密统计信息。

定义:

struct tipc_crypto_stats {
    unsigned int stat[MAX_STATS];
};

成员

stat

加密统计信息数组。

struct tipc_crypto

TIPC TX/RX 加密结构。

定义:

struct tipc_crypto {
    struct net *net;
    struct tipc_node *node;
    struct tipc_aead __rcu *aead[KEY_MAX + 1];
    atomic_t peer_rx_active;
    u16 key_gen;
    struct tipc_key key;
    u8 skey_mode;
    struct tipc_aead_key *skey;
    struct workqueue_struct *wq;
    struct delayed_work work;
#define KEY_DISTR_SCHED         1;
#define KEY_DISTR_COMPL         2;
    atomic_t key_distr;
    u32 rekeying_intv;
    struct tipc_crypto_stats __percpu *stats;
    char name[48];
    atomic64_t sndnxt ;
    unsigned long timer1;
    unsigned long timer2;
    union {
        struct {
            u8 working:1;
            u8 key_master:1;
            u8 legacy_user:1;
            u8 nokey: 1;
        };
        u8 flags;
    };
    spinlock_t lock;
};

成员

net

struct net

节点。

TIPC 节点 (RX)。

aead

指向用于加密/解密的 AEAD 密钥的指针数组。

peer_rx_active

复制的对等 RX 活动密钥索引。

key_gen

TX/RX 密钥生成。

key

密钥状态。

skey_mode

会话密钥的模式。

skey

接收到的会话密钥。

wq

TX 加密上的公共工作队列。

工作。

针对 TX/RX 的延迟工作计划。

key_distr

密钥分发状态。

rekeying_intv

重新密钥间隔（以分钟为单位）。

stats

加密统计信息。

name

加密名称。

sndnxt

每个对等方的 sndnxt (TX)。

timer1

通用计时器 1 (jiffies)。

timer2

通用计时器 2 (jiffies)。

{未命名联合}

匿名。

{未命名结构}

匿名。

working

加密是否正在工作。

key_master

标志指示主密钥是否存在。

legacy_user

标志指示对等方是否在没有主密钥的情况下加入（用于向后兼容）。

nokey

无密钥指示。

标志。

组合的标志字段。

lock

tipc_key 锁。

int tipc_aead_key_validate(struct tipc_aead_key *ukey, struct genl_info *info)

验证 AEAD 用户密钥

参数

struct tipc_aead_key *ukey

指向用户密钥数据的指针

struct genl_info *info

netlink 信息指针

int tipc_aead_key_generate(struct tipc_aead_key *skey)

生成新的会话密钥

参数

struct tipc_aead_key *skey

输入/输出密钥，包含新内容

返回

成功时返回 0，否则返回 < 0

void tipc_aead_free(struct rcu_head *rp)

释放 AEAD 密钥，包括列表中的所有 TFM

参数

struct rcu_head *rp

rcu 头指针

struct crypto_aead *tipc_aead_tfm_next(struct tipc_aead *aead)

将 TFM 条目移动到列表中的下一个，并返回它

参数

struct tipc_aead *aead

AEAD 密钥指针

int tipc_aead_init(struct tipc_aead **aead, struct tipc_aead_key *ukey, u8 mode)

初始化 TIPC AEAD

参数

struct tipc_aead **aead

返回新的 TIPC AEAD 密钥句柄指针

struct tipc_aead_key *ukey

指向用户密钥数据的指针

u8 mode

密钥模式

描述

如果用户密钥数据有效，则使用特定的用户密钥数据分配一个（或多个）新的密码转换 (TFM)。可以通过 sysfs “net/tipc/max_tfms” 设置分配的 TFM 数量。此外，还会初始化所有其他 AEAD 数据。

返回

如果初始化成功，则返回 0，否则返回：< 0

int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src)

克隆 TIPC AEAD 密钥

参数

struct tipc_aead **dst

用于克隆的目标密钥

struct tipc_aead *src

要从中克隆的源密钥

描述

将源 AEAD 密钥数据的“副本”复制到目标，TFM 列表对于密钥是通用的。为了方便以后的释放，在 “cloned” 指针中保存了对源的引用。

注意

这必须仅在集群密钥模式下完成！

返回

成功时返回 0，否则返回 < 0

void *tipc_aead_mem_alloc(struct crypto_aead *tfm, unsigned int crypto_ctx_size, u8 **iv, struct aead_request **req, struct scatterlist **sg, int nsg)

为 AEAD 请求操作分配内存

参数

struct crypto_aead *tfm

要注册到请求的密码句柄

unsigned int crypto_ctx_size

用于回调的密码上下文的大小

u8 **iv

返回的指向 IV 数据的指针

struct aead_request **req

返回的指向 AEAD 请求数据的指针

struct scatterlist **sg

返回的指向 SG 列表的指针

int nsg

要分配的 SG 列表的数量

描述

分配内存以存储密码上下文数据、AEAD 请求、IV 和 SG 列表，内存布局如下：crypto_ctx || iv || aead_req || sg[]

返回

如果成功，则返回指向内存区域的指针，否则返回 NULL

int tipc_aead_encrypt(struct tipc_aead *aead, struct sk_buff *skb, struct tipc_bearer *b, struct tipc_media_addr *dst, struct tipc_node *__dnode)

加密消息

参数

struct tipc_aead *aead

用于消息加密的 TIPC AEAD 密钥

struct sk_buff *skb

输入/输出 skb

struct tipc_bearer *b

消息加密后将传递到的 TIPC 承载

struct tipc_media_addr *dst

目标媒体地址

struct tipc_node *__dnode

如果 “已知” 的 TIPC 目标节点

返回

  • 0 : 如果加密已完成

  • -EINPROGRESS/-EBUSY : 如果将执行回调

  • < 0 : 加密失败

int tipc_aead_decrypt(struct net *net, struct tipc_aead *aead, struct sk_buff *skb, struct tipc_bearer *b)

解密加密的消息

参数

struct net *net

struct net

struct tipc_aead *aead

用于消息解密的 TIPC AEAD

struct sk_buff *skb

输入/输出 skb

struct tipc_bearer *b

消息接收自的 TIPC 承载

返回

  • 0 : 如果解密已完成

  • -EINPROGRESS/-EBUSY : 如果将执行回调

  • < 0 : 解密失败

bool tipc_ehdr_validate(struct sk_buff *skb)

验证加密消息

参数

struct sk_buff *skb

消息缓冲区

返回

如果这是一个有效的加密消息，则为“true”，否则为“false”

int tipc_ehdr_build(struct net *net, struct tipc_aead *aead, u8 tx_key, struct sk_buff *skb, struct tipc_crypto *__rx)

构建 TIPC 加密消息头

参数

struct net *net

struct net

struct tipc_aead *aead

用于消息加密的 TX AEAD 密钥

u8 tx_key

用于消息加密的密钥 ID

struct sk_buff *skb

输入/输出消息 skb

struct tipc_crypto *__rx

如果目标是“已知”的，则为 RX 加密句柄

返回

如果构建成功，则为头大小，否则为 < 0

int tipc_crypto_key_init(struct tipc_crypto *c, struct tipc_aead_key *ukey, u8 mode, bool master_key)

初始化新的用户/AEAD 密钥

参数

struct tipc_crypto *c

要将新密钥附加到的 TIPC 加密

struct tipc_aead_key *ukey

用户密钥

u8 mode

密钥模式 (CLUSTER_KEY 或 PER_NODE_KEY)

bool master_key

指定这是一个集群主密钥

描述

将分配一个新的 TIPC AEAD 密钥，并使用指定的用户密钥进行初始化，然后附加到 TIPC 加密。

返回

如果成功，则为新的密钥 ID，否则： < 0

int tipc_crypto_key_attach(struct tipc_crypto *c, struct tipc_aead *aead, u8 pos, bool master_key)

将新的 AEAD 密钥附加到 TIPC 加密

参数

struct tipc_crypto *c

要将新的 AEAD 密钥附加到的 TIPC 加密

struct tipc_aead *aead

新的 AEAD 密钥指针

u8 pos

加密密钥数组中的所需插槽，如果任意则 = 0！

bool master_key

指定这是一个集群主密钥

返回

如果成功，则为新的密钥 ID，否则：-EBUSY

bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending)

如果可能，对齐 RX 密钥

参数

struct tipc_crypto *rx

RX 加密句柄

u8 new_pending

如果对齐，则为新的挂起插槽（=来自对等方的 TX 密钥）

描述

对等方使用了未知的密钥插槽，这仅在对等方离开并重新加入或我们是新加入者时才会发生。这意味着，必须没有活动密钥，而是在未对齐的插槽中有一个挂起的密钥。如果是这样，我们将尝试将挂起的密钥移动到新插槽。

注意

可能存在一个潜在的被动密钥，它将被相应地移动！

返回

如果密钥成功对齐，则为“true”，否则为“false”

struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx, struct tipc_crypto *rx, struct sk_buff *skb, u8 tx_key)

选择一个用于消息解密的 TX 密钥

参数

struct tipc_crypto *tx

TX 加密句柄

struct tipc_crypto *rx

RX 加密句柄（可以为 NULL）

struct sk_buff *skb

稍后将解密的消息 skb

u8 tx_key

对等方 TX 密钥 ID

描述

此函数查找现有的 TX 密钥，并选择一个适合消息解密的密钥，该密钥必须是集群密钥，并且以前未在同一消息上使用过（即递归）。

返回

如果成功，则为 TX AEAD 密钥句柄，否则为 NULL

void tipc_crypto_key_synch(struct tipc_crypto *rx, struct sk_buff *skb)

根据对等密钥状态同步自己的密钥数据

参数

struct tipc_crypto *rx

RX 加密句柄

struct sk_buff *skb

TIPCv2 消息缓冲区（包括来自对等方的 ehdr）

描述

此函数在对等方 RX 活动密钥更改时更新对等节点的相关数据，因此此节点上 TX 密钥的用户数量会相应增加和减少。

它还考虑了对等方是否没有密钥，那么我们需要使自己的主密钥（如果有）接管，即开始宽限期，并触发密钥分配过程。

当对等密钥切换时，还会重置“每个对等方”的 sndnxt。

int tipc_crypto_xmit(struct net *net, struct sk_buff **skb, struct tipc_bearer *b, struct tipc_media_addr *dst, struct tipc_node *__dnode)

构建并加密用于 xmit 的 TIPC 消息

参数

struct net *net

struct net

struct sk_buff **skb

输入/输出消息 skb 指针

struct tipc_bearer *b

稍后用于 xmit 的承载

struct tipc_media_addr *dst

目标媒体地址

struct tipc_node *__dnode

如果存在，则作为参考的目标节点

描述

首先，在消息顶部构建一个加密消息头，然后使用挂起、主密钥或活动密钥（按此优先级顺序）加密原始 TIPC 消息。如果加密成功，则加密的 skb 将直接或通过回调返回。否则，skb 将被释放！

返回

  • 0：加密已成功（或未加密）

  • -EINPROGRESS/-EBUSY：加密正在进行中，将进行回调

  • -ENOKEK

    ：由于没有密钥，加密失败

  • -EKEYREVOKED

    ：由于密钥被撤销，加密失败

  • -ENOMEM

    ：由于没有内存，加密失败

  • < 0：由于其他原因，加密失败

int tipc_crypto_rcv(struct net *net, struct tipc_crypto *rx, struct sk_buff **skb, struct tipc_bearer *b)

解密来自对端的已加密 TIPC 消息

参数

struct net *net

struct net

struct tipc_crypto *rx

RX 加密句柄

struct sk_buff **skb

输入/输出消息 skb 指针

struct tipc_bearer *b

消息接收自的承载层。

描述

如果解密成功，解密后的 skb 将直接返回或作为回调返回。在转发到 tipc_rcv() 之前，会通过 tipc_crypto_rcv_complete() 移除加密头和认证标签。否则，skb 将会被释放！

注意

RX 密钥可以重新对齐，或者在没有合适的密钥的情况下，可以使用 TX 集群密钥进行解密（- 递归）。

返回

  • 0 : 解密已成功完成

  • -EINPROGRESS/-EBUSY : 解密正在进行中，将会进行回调

  • -ENOKEY

    : 由于没有密钥，解密失败

  • -EBADMSG

    : 由于错误的消息，解密失败

  • -ENOMEM

    : 由于内存不足，解密失败

  • < 0 : 由于其他原因，解密失败

void tipc_crypto_msg_rcv(struct net *net, struct sk_buff *skb)

通用的 ‘MSG_CRYPTO’ 处理点

参数

struct net *net

struct net

struct sk_buff *skb

接收消息缓冲区

int tipc_crypto_key_distr(struct tipc_crypto *tx, u8 key, struct tipc_node *dest)

分发 TX 密钥

参数

struct tipc_crypto *tx

TX 加密

u8 key

密钥的索引

struct tipc_node *dest

目标 tipc 节点，如果分发到所有节点，则为 NULL

返回

成功时返回 0，否则返回 < 0

int tipc_crypto_key_xmit(struct net *net, struct tipc_aead_key *skey, u16 gen, u8 mode, u32 dnode)

发送会话密钥

参数

struct net *net

struct net

struct tipc_aead_key *skey

要发送的会话密钥

u16 gen

密钥的生成。

u8 mode

密钥的模式

u32 dnode

目标节点地址，如果广播到所有节点，则为 0

描述

会话密钥 ‘skey’ 被打包在 TIPC v2 ‘MSG_CRYPTO/KEY_DISTR_MSG’ 中作为其数据部分，然后通过 uc/bc 链路发送。

返回

成功时返回 0，否则返回 < 0

bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr)

接收会话密钥

参数

struct tipc_crypto *rx

RX 加密

struct tipc_msg *hdr

TIPC v2 消息，包括其数据中接收的会话密钥

描述

此函数检索对等消息中的会话密钥，然后调度 RX 工作将密钥附加到相应的 RX 加密。

返回

如果已计划附加密钥，则为“true”，否则为“false”。

void tipc_crypto_work_rx(struct work_struct *work)

计划的 RX 工作处理程序

参数

struct work_struct *work

struct RX 工作

描述

此函数处理先前计划的工作，即分发 TX 密钥或将接收到的会话密钥附加到 RX 加密。

void tipc_crypto_rekeying_sched(struct tipc_crypto *tx, bool changed, u32 new_intv)

（重新）安排重新密钥，无需新间隔

参数

struct tipc_crypto *tx

TX 加密

bool changed

如果需要使用新间隔重新安排重新密钥

u32 new_intv

新的重新密钥间隔（当 “changed” = true 时）

void tipc_crypto_work_tx(struct work_struct *work)

计划的 TX 工作处理程序

参数

struct work_struct *work

struct TX 工作

描述

此函数处理先前计划的工作，即密钥重新密钥，方法是基于当前密钥生成新的会话密钥，然后将其附加到 TX 加密，最后将其分发给对等方。如果需要，它还会重新安排重新密钥。

TIPC 发现器接口

struct tipc_discoverer

关于正在进行的链路建立请求的信息

定义:

struct tipc_discoverer {
    u32 bearer_id;
    struct tipc_media_addr dest;
    struct net *net;
    u32 domain;
    int num_nodes;
    spinlock_t lock;
    struct sk_buff *skb;
    struct timer_list timer;
    unsigned long timer_intv;
};

成员

bearer_id

发出请求的承载层的标识

dest

请求消息的目标地址

net

网络命名空间实例

domain

可以建立链路的网络域

num_nodes

当前发现的节点数（即具有活动链路的节点）

lock

用于控制对请求的访问的自旋锁

skb

要（重复）发送的请求消息

timer

控制请求之间周期的计时器

timer_intv

当前请求之间的时间间隔（以毫秒为单位）

void tipc_disc_init_msg(struct net *net, struct sk_buff *skb, u32 mtyp, struct tipc_bearer *b)

初始化链路建立消息

参数

struct net *net

适用的 net 命名空间

struct sk_buff *skb

包含消息的缓冲区

u32 mtyp

消息类型（请求或响应）

struct tipc_bearer *b

指向发出消息的承载层的指针

void disc_dupl_alert(struct tipc_bearer *b, u32 node_addr, struct tipc_media_addr *media_addr)

发出节点地址重复警报

参数

struct tipc_bearer *b

指向承载检测重复的指针

u32 node_addr

重复的节点地址

struct tipc_media_addr *media_addr

由重复节点发布的媒体地址

void tipc_disc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)

处理传入的发现消息（请求或响应）

参数

struct net *net

适用的网络命名空间

struct sk_buff *skb

包含消息的缓冲区

struct tipc_bearer *b

消息到达的承载

int tipc_disc_create(struct net *net, struct tipc_bearer *b, struct tipc_media_addr *dest, struct sk_buff **skb)

创建用于发送定期链路建立请求的对象

参数

struct net *net

适用的 net 命名空间

struct tipc_bearer *b

指向发出请求的承载的指针

struct tipc_media_addr *dest

请求消息的目标地址

struct sk_buff **skb

指向已创建帧的指针

返回

成功则为 0，否则为 -errno。

void tipc_disc_delete(struct tipc_discoverer *d)

销毁发送定期链路建立请求的对象

参数

struct tipc_discoverer *d

指向链路目标结构的指针

void tipc_disc_reset(struct net *net, struct tipc_bearer *b)

重置对象以发送定期链路建立请求

参数

struct net *net

适用的 net 命名空间

struct tipc_bearer *b

指向发出请求的承载的指针

TIPC 消息接口

struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp)

创建 TIPC 消息缓冲区

参数

u32 size

消息大小（包括 TIPC 头部）

gfp_t gfp

内存分配标志

返回

一个新缓冲区，其数据指针设置为指定大小。

注意

预留了头部空间，以允许在数据链路头部前添加内容。缓冲区的末尾可能还存在未请求的尾部空间。

int tipc_msg_append(struct tipc_msg *_hdr, struct msghdr *m, int dlen, int mss, struct sk_buff_head *txq)

将数据附加到现有缓冲区队列的尾部

参数

struct tipc_msg *_hdr

要使用的头部

struct msghdr *m

要附加的数据

int dlen

要附加的数据的大小

int mss

缓冲区允许的最大大小

struct sk_buff_head *txq

要附加到的队列

返回

附加的 1k 块的数量或 errno 值

int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr, int pktmax, struct sk_buff_head *frags)

为 TIPC 消息构建分片 skb 列表

参数

struct sk_buff *skb

TIPC 消息 skb

const struct tipc_msg *hdr

要放在分片顶部的内部消息头

int pktmax

分片的最大大小（包括头部）

struct sk_buff_head *frags

返回的分片 skb 列表

返回

如果分片成功，则为 0，否则为：-EINVAL 或 -ENOMEM

int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, int offset, int dsz, int pktmax, struct sk_buff_head *list)

创建包含指定头部和数据的缓冲区链

参数

struct tipc_msg *mhdr

消息头部，要预先添加到数据

struct msghdr *m

用户消息

int offset

分片消息的缓冲区偏移量（待修复）

int dsz

用户数据的总长度

int pktmax

可以使用的最大数据包大小

struct sk_buff_head *list

要返回给调用者的缓冲区或缓冲区链

描述

请注意，我们在这里进行的递归调用是安全的，因为它在逻辑上只能再向下走一级。

返回

消息数据大小或 errno：-ENOMEM、-EFAULT

bool tipc_msg_bundle(struct sk_buff *bskb, struct tipc_msg *msg, u32 max)

将缓冲区的内容附加到现有缓冲区的尾部

参数

struct sk_buff *bskb

要附加到的捆绑缓冲区

struct tipc_msg *msg

要附加的消息

u32 max

捆绑缓冲区允许的最大大小

返回

如果已执行捆绑，则为 “true”，否则为 “false”

bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss, u32 dnode, bool *new_bundle)

尝试将新消息捆绑到最后一个消息

参数

struct sk_buff *tskb

新消息将附加到的最后一个/目标消息

struct sk_buff **skb

新消息 skb 指针

u32 mss

最大消息大小（包括头部）

u32 dnode

消息的目标节点

bool *new_bundle

此调用是否创建了新的捆绑

返回

如果新消息 skb 本次或稍后有可能进行捆绑，则为 “true”，在这种情况下，如果本次已完成捆绑，则会使用 skb（skb 指针 = NULL）。否则，如果 skb 根本无法捆绑，则为 “false”。

bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos)

从缓冲区中提取捆绑的内部数据包

参数

struct sk_buff *skb

要从中提取的缓冲区。

struct sk_buff **iskb

提取的内部缓冲区，要返回

int *pos

外部消息中要提取的消息的位置。返回下一条消息的位置。提取最后一个数据包时会使用外部缓冲区

返回

当存在提取的缓冲区时为 true，否则为 false

bool tipc_msg_reverse(u32 own_node, struct sk_buff **skb, int err)

交换源地址和目标地址，并添加错误代码

参数

u32 own_node

反转消息的原始节点 ID

struct sk_buff **skb

包含要反转的消息的缓冲区；将被消耗

int err

要设置在消息中的错误代码（如果有）。成功时，用新的缓冲区替换已消耗的缓冲区

返回

成功时为 true，否则为 false

bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err)

尝试为命名消息查找新的目标地址

参数

struct net *net

指向关联网络命名空间的指针

struct sk_buff *skb

包含消息的缓冲区。

int *err

如果查找失败，则由调用方使用的错误代码。不消耗缓冲区

返回

如果找到目标地址则为 true，否则为 false

TIPC 名称接口

struct service_range

服务范围的所有绑定的容器

定义:

struct service_range {
    u32 lower;
    u32 upper;
    struct rb_node tree_node;
    u32 max;
    struct list_head local_publ;
    struct list_head all_publ;
};

成员

lower

服务范围的下限

upper

服务范围的上限

tree_node

服务范围 RB 树的成员

最大值

此节点子树中最大的“上限”值

local_publ

从该节点进行的所有相同发布的列表。由 closest_first 查找和多播查找算法使用

all_publ

与此相同的所有发布，无论节点和范围如何。由轮询查找算法使用

struct tipc_service

服务类型的所有已发布实例的容器

定义:

struct tipc_service {
    u32 type;
    u32 publ_cnt;
    struct rb_root ranges;
    struct hlist_node service_list;
    struct list_head subscriptions;
    spinlock_t lock;
    struct rcu_head rcu;
};

成员

type

服务的 32 位“类型”值

publ_cnt

此服务中发布的递增计数器

ranges

包含此服务的所有服务范围的 rb 树

service_list

指向哈希链中相邻名称范围的链接

订阅

此服务类型的订阅列表

lock

控制访问相关服务范围/发布的自旋锁

rcu

用于延迟释放的 RCU 回调头

service_range_foreach_match

service_range_foreach_match (sr, sc, start, end)

迭代 tipc 服务 rbtree 以查找每个范围匹配项

参数

sr

服务范围指针，作为循环光标

sc

指向保存服务范围 rbtree 的 tipc 服务的指针

start

匹配搜索范围的起始位置（end >= start）

end

匹配搜索范围的结束位置（end >= start）

struct service_range *service_range_match_first(struct rb_node *n, u32 start, u32 end)

查找与范围匹配的第一个服务范围

参数

struct rb_node *n

用于搜索的服务范围 rbtree 的根节点

u32 start

匹配搜索范围的起始位置（end >= start）

u32 end

匹配搜索范围的结束位置（end >= start）

返回

rbtree 中与特定范围重叠的最左侧服务范围节点（如果有）。否则，返回 NULL。

struct service_range *service_range_match_next(struct rb_node *n, u32 start, u32 end)

查找与范围匹配的下一个服务范围

参数

struct rb_node *n

服务范围 rbtree 中的一个节点，搜索从该节点开始

u32 start

匹配搜索范围的起始位置（end >= start）

u32 end

匹配搜索范围的结束位置（end >= start）

返回

rbtree 中给定节点的下一个服务范围节点，该节点与特定范围重叠（如果有）。否则，返回 NULL。

struct publication *tipc_publ_create(struct tipc_uaddr *ua, struct tipc_socket_addr *sk, u32 key)

创建发布结构

参数

struct tipc_uaddr *ua

用户正在绑定的服务范围

struct tipc_socket_addr *sk

绑定的套接字的地址

u32 key

publication key

struct tipc_service *tipc_service_create(struct net *net, struct tipc_uaddr *ua)

为指定的“类型”创建服务结构

参数

struct net *net

网络命名空间。

struct tipc_uaddr *ua

表示要绑定的服务的地址

描述

分配一个单独的范围结构，并将其设置为全部为 0。

struct publication *tipc_service_remove_publ(struct service_range *r, struct tipc_socket_addr *sk, u32 key)

从服务中删除发布

参数

struct service_range *r

要从中删除发布的服务范围

struct tipc_socket_addr *sk

发布套接字地址

u32 key

目标发布密钥

void tipc_service_subscribe(struct tipc_service *service, struct tipc_subscription *sub)

附加订阅，如果任何服务范围与请求的范围重叠，则可以选择性地发出规定数量的事件

参数

struct tipc_service *service

要将 sub 附加到的 tipc_service

struct tipc_subscription *sub

要附加的订阅

bool tipc_nametbl_lookup_anycast(struct net *net, struct tipc_uaddr *ua, struct tipc_socket_addr *sk)

执行服务实例到套接字的转换。

参数

struct net *net

网络命名空间。

struct tipc_uaddr *ua

要查找的服务地址。

struct tipc_socket_addr *sk

我们要查找的套接字的地址。

描述

在入口处，非零的 ‘sk->node’ 指示我们希望执行查找的节点，该节点可能不是当前节点。

在出口处：

  • 如果查找被推迟到另一个节点，则保持 ‘sk->node’ 不变并返回 ‘true’。

  • 如果查找成功，则设置 ‘sk->node’ 和 ‘sk->ref’ (== portid)，它们表示绑定的套接字，并返回 ‘true’。

  • 如果查找失败，则返回 ‘false’。

请注意，对于旧用户（配置了 Z.C.N 地址格式的节点），必须保持“最近优先”查找算法，即如果 sk.node 为 0，我们必须首先在本地绑定列表中查找。

void tipc_nametbl_withdraw(struct net *net, struct tipc_uaddr *ua, struct tipc_socket_addr *sk, u32 key)

撤销服务绑定。

参数

struct net *net

网络命名空间。

struct tipc_uaddr *ua

正在解除绑定的服务地址/范围。

struct tipc_socket_addr *sk

正在解除绑定的套接字的地址。

u32 key

目标发布密钥

bool tipc_nametbl_subscribe(struct tipc_subscription *sub)

向名称表添加订阅对象。

参数

struct tipc_subscription *sub

要添加的订阅。

void tipc_nametbl_unsubscribe(struct tipc_subscription *sub)

从名称表中删除订阅对象。

参数

struct tipc_subscription *sub

要删除的订阅。

void tipc_service_delete(struct net *net, struct tipc_service *sc)

清除服务的所有发布信息并删除它。

参数

struct net *net

关联的网络命名空间。

struct tipc_service *sc

要删除的 tipc_service。

void publ_to_item(struct distr_item *i, struct publication *p)

将发布信息添加到发布消息中。

参数

struct distr_item *i

消息中项目的位置。

struct publication *p

发布信息。

struct sk_buff *named_prepare_buf(struct net *net, u32 type, u32 size, u32 dest)

分配并初始化发布消息。

参数

struct net *net

关联的网络命名空间。

u32 type

消息类型。

u32 size

有效负载大小。

u32 dest

目标节点。

描述

返回的缓冲区大小为 INT_H_SIZE + 有效负载大小。

struct sk_buff *tipc_named_publish(struct net *net, struct publication *p)

告知其他节点此节点的新发布信息。

参数

struct net *net

关联的网络命名空间。

struct publication *p

新的发布信息。

struct sk_buff *tipc_named_withdraw(struct net *net, struct publication *p)

告知其他节点此节点已撤回的发布信息。

参数

struct net *net

关联的网络命名空间。

struct publication *p

已撤回的发布信息。

void named_distribute(struct net *net, struct sk_buff_head *list, u32 dnode, struct list_head *pls, u16 seqno)

准备用于批量分发到另一个节点的名称信息。

参数

struct net *net

关联的网络命名空间。

struct sk_buff_head *list

此函数返回的消息（缓冲区）列表。

u32 dnode

要更新的节点。

struct list_head *pls

要打包到缓冲区链中的发布项目链接列表。

u16 seqno

此消息的序列号。

void tipc_named_node_up(struct net *net, u32 dnode, u16 capabilities)

告知指定节点此节点的所有发布信息。

参数

struct net *net

关联的网络命名空间。

u32 dnode

目标节点。

u16 capabilities

对等节点的功能。

void tipc_publ_purge(struct net *net, struct publication *p, u32 addr)

移除与失败节点关联的发布信息

参数

struct net *net

关联的网络命名空间。

struct publication *p

要移除的发布信息

u32 addr

失败节点的地址

描述

为每个由新失败节点发布的发布信息调用。从名称表中删除发布结构并删除它。

bool tipc_update_nametbl(struct net *net, struct distr_item *i, u32 node, u32 dtype)

尝试处理名称表更新并通知订阅者

参数

struct net *net

关联的网络命名空间。

struct distr_item *i

消息中项目的位置。

u32 node

节点地址

u32 dtype

名称分发器消息类型

描述

必须持有 tipc_nametbl_lock。

返回

如果成功，则为发布项，否则为 NULL。

void tipc_named_rcv(struct net *net, struct sk_buff_head *namedq, u16 *rcv_nxt, bool *open)

处理由另一个节点发送的名称表更新消息

参数

struct net *net

关联的网络命名空间。

struct sk_buff_head *namedq

从中接收的队列

u16 *rcv_nxt

在此处存储上次接收到的序列号

bool *open

已收到最后一个批量消息 (FIXME)

void tipc_named_reinit(struct net *net)

重新初始化本地发布

参数

struct net *net

关联的网络命名空间。

描述

每当启用 TIPC 网络时，都会调用此例程。此节点发布的所有名称表条目都将更新，以反映该节点的新网络地址。

TIPC 节点管理接口

struct tipc_node

TIPC 节点结构

定义:

struct tipc_node {
    u32 addr;
    struct kref kref;
    rwlock_t lock;
    struct net *net;
    struct hlist_node hash;
    int active_links[2];
    struct tipc_link_entry links[MAX_BEARERS];
    struct tipc_bclink_entry bc_entry;
    int action_flags;
    struct list_head list;
    int state;
    bool preliminary;
    bool failover_sent;
    u16 sync_point;
    int link_cnt;
    u16 working_links;
    u16 capabilities;
    u32 signature;
    u32 link_id;
    u8 peer_id[16];
    char peer_id_string[NODE_ID_STR_LEN];
    struct list_head publ_list;
    struct list_head conn_sks;
    unsigned long keepalive_intv;
    struct timer_list timer;
    struct rcu_head rcu;
    unsigned long delete_at;
    struct net *peer_net;
    u32 peer_hash_mix;
#ifdef CONFIG_TIPC_CRYPTO;
    struct tipc_crypto *crypto_rx;
#endif;
};

成员

addr

节点的网络地址

kref

节点对象的引用计数器

lock

控制结构访问的读写锁

net

适用的 net 命名空间

哈希值

指向未排序哈希链中相邻节点的链接

active_links

活动链接的承载 ID，用作 links[] 数组的索引

links

包含指向节点的所有链接的引用的数组

bc_entry

广播链接条目

action_flags

不同类型的节点操作的位掩码

list

指向集群节点排序列表中的相邻节点的链接

state

与对等节点的连接状态

preliminary

是否为预备节点

failover_sent

是否已发送故障转移

sync_point

同步/故障转移完成的序列号

link_cnt

指向节点的链接数

working_links

指向节点的工作链接数（活动和备用）

capabilities

位图，指示对等节点的功能

signature

节点实例标识符

link_id

如果有的话，正在更改的链接的本地和远程承载 ID

peer_id

对等方的 128 位 ID

peer_id_string

对等方的 ID 字符串

publ_list

发布列表

conn_sks

连接列表 (FIXME)

keepalive_intv

保持活动间隔（以毫秒为单位）

timer

节点的保持活动定时器

rcu

tipc_node 的 rcu 结构

delete_at

指示删除关闭节点的时间

peer_net

对等方的网络命名空间

peer_hash_mix

此对等方的哈希值 (FIXME)

crypto_rx

RX 加密处理程序

struct tipc_crypto *tipc_node_crypto_rx(struct tipc_node *__n)

从节点检索加密 RX 处理程序

参数

struct tipc_node *__n

目标 tipc_node

注意

必须先持有节点引用计数器！

void __tipc_node_link_up(struct tipc_node *n, int bearer_id, struct sk_buff_head *xmitq)

处理链接的添加

参数

struct tipc_node *n

目标 tipc_node

int bearer_id

承载器的 ID

struct sk_buff_head *xmitq

用于在节点锁必须由调用方持有的情况下传输消息的队列。链接将根据其优先级变为活动状态（单独或共享）或备用状态。

处理链接的添加

参数

struct tipc_node *n

目标 tipc_node

int bearer_id

承载器的 ID

struct sk_buff_head *xmitq

用于传输消息的队列

描述

链接将根据其优先级变为活动状态（单独或共享）或备用状态。

在“半故障转移”的情况下启动故障转移

参数

struct tipc_node *n

tipc 节点结构

struct tipc_link *l

正在进行故障转移的链接对等端点（- 可以为 NULL）

struct tipc_link *tnl

隧道链接

struct sk_buff_head *xmitq

稍后在 tnl 链接上发送消息的队列

描述

此函数仅在一种非常特殊的情况下被调用，即对等节点上已可以启动链接故障转移，但在此节点上尚未启动。 例如，当

1. Both links <1A-2A>, <1B-2B> down
2. Link endpoint 2A up, but 1A still down (e.g. due to network
disturbance, wrong session, etc.)
3. Link <1B-2B> up
4. Link endpoint 2A down (e.g. due to link tolerance timeout)
5. Node 2 starts failover onto link <1B-2B>

==> Node 1 does never start link/node failover!
void __tipc_node_link_down(struct tipc_node *n, int *bearer_id, struct sk_buff_head *xmitq, struct tipc_media_addr **maddr)

处理链接丢失

参数

struct tipc_node *n

目标 tipc_node

int *bearer_id

承载器的 ID

struct sk_buff_head *xmitq

用于传输消息的队列

struct tipc_media_addr **maddr

承载器的输出媒体地址

int tipc_node_get_linkname(struct net *net, u32 bearer_id, u32 addr, char *linkname, size_t len)

获取链接的名称

参数

struct net *net

适用的 net 命名空间

u32 bearer_id

承载器的 ID

u32 addr

对等节点的地址

char *linkname

链接名称输出缓冲区

size_t len

linkname 输出缓冲区的大小

返回

成功时返回 0

int tipc_node_xmit(struct net *net, struct sk_buff_head *list, u32 dnode, int selector)

用于消息发送的通用链接层函数

参数

struct net *net

适用的 net 命名空间

struct sk_buff_head *list

包含消息的缓冲区链

u32 dnode

目标节点的地址

int selector

用于确定性链接选择的数字。消耗缓冲区链。

返回

成功时返回 0，否则返回: -ELINKCONG,-EHOSTUNREACH,-EMSGSIZE,-ENOBUF

void tipc_node_bc_rcv(struct net *net, struct sk_buff *skb, int bearer_id)

处理来自节点外的 TIPC 广播数据包

参数

struct net *net

适用的 net 命名空间

struct sk_buff *skb

TIPC 数据包

int bearer_id

消息到达的承载 ID

描述

调用时未持有锁。

bool tipc_node_check_state(struct tipc_node *n, struct sk_buff *skb, int bearer_id, struct sk_buff_head *xmitq)

检查并在必要时更新节点状态

参数

struct tipc_node *n

目标 tipc_node

struct sk_buff *skb

TIPC 数据包

int bearer_id

传送数据包的承载的标识

struct sk_buff_head *xmitq

用于传输消息的队列

返回

如果状态和消息正常则返回 true，否则返回 false

void tipc_rcv(struct net *net, struct sk_buff *skb, struct tipc_bearer *b)

处理来自节点外的 TIPC 数据包/消息

参数

struct net *net

适用的 net 命名空间

struct sk_buff *skb

TIPC 数据包

struct tipc_bearer *b

指向消息到达的承载的指针

描述

调用时未持有锁。承载指针必须指向有效的承载结构（即不能为 NULL），但承载可能处于非活动状态。

int tipc_node_dump(struct tipc_node *n, bool more, char *buf)

转储 TIPC 节点数据

参数

struct tipc_node *n

要转储的 tipc 节点

bool more

是否转储更多？ - false：仅转储 tipc 节点数据 - true：同时转储节点链接数据

char *buf

以格式返回的转储数据缓冲区

TIPC 套接字接口

struct tipc_sock

TIPC 套接字结构

定义:

struct tipc_sock {
    struct sock sk;
    u32 max_pkt;
    u32 maxnagle;
    u32 portid;
    struct tipc_msg phdr;
    struct list_head cong_links;
    struct list_head publications;
    u32 pub_count;
    atomic_t dupl_rcvcnt;
    u16 conn_timeout;
    bool probe_unacked;
    u16 cong_link_cnt;
    u16 snt_unacked;
    u16 snd_win;
    u16 peer_caps;
    u16 rcv_unacked;
    u16 rcv_win;
    struct sockaddr_tipc peer;
    struct rhash_head node;
    struct tipc_mc_method mc_method;
    struct rcu_head rcu;
    struct tipc_group *group;
    u32 oneway;
    u32 nagle_start;
    u16 snd_backlog;
    u16 msg_acc;
    u16 pkt_cnt;
    bool expect_ack;
    bool nodelay;
    bool group_is_open;
    bool published;
    u8 conn_addrtype;
};

成员

sk

套接字 - 通过套接字 API 与“端口”和用户交互

max_pkt

构建端口发送的消息时使用的最大数据包大小“提示”

maxnagle

可以进行 Nagle 算法的最大消息大小

portid

TIPC 套接字哈希表中唯一的端口标识

phdr

发送消息时使用的预格式化消息头

cong_links

拥塞链接的列表

publications

端口的发布列表

pub_count

端口在其生命周期内进行的发布总数

dupl_rcvcnt

在积压和接收队列中都被计算在内的字节数

conn_timeout

等待未响应的设置请求的时间

probe_unacked

探测尚未收到确认

cong_link_cnt

拥塞链接的数量

snt_unacked

套接字发送但对等方尚未确认的消息数

snd_win

发送窗口大小

peer_caps

对等方功能掩码

rcv_unacked

用户读取但尚未确认回对等方的消息数

rcv_win

接收窗口大小

peer

dgram/rdm 的“已连接”对等方

节点。

哈希表节点

mc_method

用于套接字和广播层之间的 cookie

rcu

tipc_sock 的 rcu 结构

group

TIPC 通信组

oneway

一个方向上的消息计数 (FIXME)

nagle_start

当前 Nagle 值

snd_backlog

发送积压计数

msg_acc

接受的消息；用于管理积压和 Nagle 算法

pkt_cnt

TIPC 套接字数据包计数

expect_ack

此 TIPC 套接字是否正在等待确认

nodelay

setsockopt() TIPC_NODELAY 设置

group_is_open

TIPC 套接字组已完全打开 (FIXME)

published

如果端口有一个或多个关联名称，则为 true

conn_addrtype

建立连接时使用的地址类型

void tsk_advance_rx_queue(struct sock *sk)

丢弃套接字接收队列中的第一个缓冲区

参数

struct sock *sk

网络套接字

描述

调用者必须持有套接字锁

void tsk_rej_rx_queue(struct sock *sk, int error)

拒绝套接字接收队列中的所有缓冲区

参数

struct sock *sk

网络套接字

int error

响应错误代码

描述

调用者必须持有套接字锁

int tipc_sk_create(struct net *net, struct socket *sock, int protocol, int kern)

创建 TIPC 套接字

参数

struct net *net

网络命名空间（必须是默认网络）

struct socket *sock

预先分配的套接字结构

int protocol

协议指示器（必须为 0）

int kern

由内核还是用户空间引起？

描述

此例程创建 TIPC 套接字使用的其他数据结构，初始化它们并将它们链接在一起。

返回

成功时返回 0，否则返回 errno

int tipc_release(struct socket *sock)

销毁一个 TIPC 套接字

参数

struct socket *sock

要销毁的套接字

描述

此例程清除套接字上仍在排队的任何消息。对于 DGRAM 和 RDM 套接字类型，所有排队的消息都会被拒绝。对于 SEQPACKET 和 STREAM 套接字类型，第一条消息会被拒绝，其他消息会被丢弃。（如果 STREAM 套接字上的第一条消息是部分读取的，则会丢弃它，并拒绝下一条消息。）

注意

被拒绝的消息不一定会返回给发送者！它们会根据发送者为消息指定的“目标可丢弃”设置返回或丢弃。

返回

成功时返回 0，否则返回 errno

int __tipc_bind(struct socket *sock, struct sockaddr *skaddr, int alen)

将 TIPC 名称与套接字关联或取消关联

参数

struct socket *sock

套接字结构

struct sockaddr *skaddr

描述名称和所需操作的套接字地址

int alen

套接字地址数据结构的大小

描述

名称和名称序列绑定使用正作用域值表示；负作用域值会取消绑定指定的名称。指定无名称（即套接字地址长度为 0）会取消绑定套接字的所有名称。

返回

成功时返回 0，否则返回 errno

注意

此例程不需要获取套接字锁，因为它不

访问任何非常量套接字信息。

int tipc_getname(struct socket *sock, struct sockaddr *uaddr, int peer)

获取套接字或对等套接字的端口 ID

参数

struct socket *sock

套接字结构

struct sockaddr *uaddr

用于返回套接字地址的区域

int peer

0 = 自己的 ID，1 = 当前对等 ID，2 = 当前/前对等 ID

返回

成功时返回 0，否则返回 errno

注意

此例程不需要获取套接字锁，因为它只

访问不变的（或以完全可预测的方式更改的）套接字信息。

__poll_t tipc_poll(struct file *file, struct socket *sock, poll_table *wait)

读取并可能在 pollmask 上阻塞

参数

struct file *file

与套接字关联的文件结构

struct socket *sock

用于计算轮询位的套接字

poll_table *wait

???

返回

pollmask 值

描述

评论：似乎通常的套接字锁定机制在这里没有用，因为轮询掩码信息在例程退出的那一刻就可能过期。TCP 和其他协议似乎依赖于更高级别的轮询例程来处理任何可预防的竞争条件，因此 TIPC 也将这样做...

重要提示：指示读取或写入操作并不意味着该操作会成功，而只是意味着应该执行该操作并且不会阻塞。

int tipc_sendmcast(struct socket *sock, struct tipc_uaddr *ua, struct msghdr *msg, size_t dlen, long timeout)

发送多播消息

参数

struct socket *sock

套接字结构

struct tipc_uaddr *ua

目标地址结构

struct msghdr *msg

要发送的消息

size_t dlen

要发送的数据长度

long timeout

等待唤醒的超时时间

描述

从函数 tipc_sendmsg() 调用，该函数已完成所有健全性检查

返回

成功发送的字节数，或 errno

int tipc_send_group_msg(struct net *net, struct tipc_sock *tsk, struct msghdr *m, struct tipc_member *mb, u32 dnode, u32 dport, int dlen)

向组中的成员发送消息

参数

struct net *net

网络命名空间。

struct tipc_sock *tsk

tipc 套接字

struct msghdr *m

要发送的消息

struct tipc_member *mb

组成员

u32 dnode

目标节点。

u32 dport

目标端口

int dlen

消息数据的总长度

int tipc_send_group_unicast(struct socket *sock, struct msghdr *m, int dlen, long timeout)

向组中的成员发送消息

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

int dlen

消息数据的总长度

long timeout

等待唤醒的超时时间

描述

从函数 tipc_sendmsg() 调用，该函数已完成所有健全性检查

返回

成功发送的字节数，或 errno

int tipc_send_group_anycast(struct socket *sock, struct msghdr *m, int dlen, long timeout)

将消息发送到具有给定标识的任何成员

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

int dlen

消息数据的总长度

long timeout

等待唤醒的超时时间

描述

从函数 tipc_sendmsg() 调用，该函数已完成所有健全性检查

返回

成功发送的字节数，或 errno

int tipc_send_group_bcast(struct socket *sock, struct msghdr *m, int dlen, long timeout)

向通信组中的所有成员发送消息

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

int dlen

消息数据的总长度

long timeout

等待唤醒的超时时间

描述

从函数 tipc_sendmsg() 调用，该函数已完成所有健全性检查

返回

成功发送的字节数，或 errno

int tipc_send_group_mcast(struct socket *sock, struct msghdr *m, int dlen, long timeout)

将消息发送给具有给定标识的所有成员

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

int dlen

消息数据的总长度

long timeout

等待唤醒的超时时间

描述

从函数 tipc_sendmsg() 调用，该函数已完成所有健全性检查

返回

成功发送的字节数，或 errno

void tipc_sk_mcast_rcv(struct net *net, struct sk_buff_head *arrvq, struct sk_buff_head *inputq)

将多播消息传递到所有目标套接字

参数

struct net *net

关联的网络命名空间。

struct sk_buff_head *arrvq

包含到达消息的队列，在目标查找后进行克隆

struct sk_buff_head *inputq

包含克隆消息的队列，在目标查找后传递到套接字

描述

多线程：可能会发生引用同一队列的并行调用

void tipc_sk_conn_proto_rcv(struct tipc_sock *tsk, struct sk_buff *skb, struct sk_buff_head *inputq, struct sk_buff_head *xmitq)

接收连接管理协议消息

参数

struct tipc_sock *tsk

接收套接字

struct sk_buff *skb

指向消息缓冲区的指针。

struct sk_buff_head *inputq

包含缓冲区的缓冲区列表

struct sk_buff_head *xmitq

输出消息区域

int tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz)

以无连接方式发送消息

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

size_t dsz

要发送的用户数据量

描述

消息必须明确指定目标。用于 SOCK_RDM 和 SOCK_DGRAM 消息，以及用于 SOCK_SEQPACKET 和 SOCK_STREAM 连接上的 'SYN' 消息。（注意：SOCK_STREAM 不允许使用 'SYN+'。）

返回

成功发送的字节数，否则为 errno

int tipc_sendstream(struct socket *sock, struct msghdr *m, size_t dsz)

发送面向流的数据

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的数据

size_t dsz

要传输的数据总长度

描述

用于 SOCK_STREAM 数据。

返回

成功发送的字节数（或部分成功），如果没有发送数据，则为 errno

int tipc_send_packet(struct socket *sock, struct msghdr *m, size_t dsz)

发送面向连接的消息

参数

struct socket *sock

套接字结构

struct msghdr *m

要发送的消息

size_t dsz

要传输的数据长度

描述

用于 SOCK_SEQPACKET 消息。

返回

成功发送的字节数，否则为 errno

void tipc_sk_set_orig_addr(struct msghdr *m, struct sk_buff *skb)

捕获接收消息的发送者地址

参数

struct msghdr *m

消息信息描述符

struct sk_buff *skb

接收到的消息

注意

如果接收者没有请求，则不会捕获地址。

int tipc_sk_anc_data_recv(struct msghdr *m, struct sk_buff *skb, struct tipc_sock *tsk)

可选地捕获接收消息的辅助数据

参数

struct msghdr *m

消息信息描述符

struct sk_buff *skb

接收到的消息缓冲区

struct tipc_sock *tsk

与消息关联的 TIPC 端口

注意

如果接收者没有请求，则不会捕获辅助数据。

返回

成功则为 0，否则为 errno

int tipc_recvmsg(struct socket *sock, struct msghdr *m, size_t buflen, int flags)

接收面向数据包的消息

参数

struct socket *sock

网络套接字

struct msghdr *m

消息信息描述符

size_t buflen

用户缓冲区区域的长度

int flags

接收标志

描述

用于 SOCK_DGRAM、SOCK_RDM 和 SOCK_SEQPACKET 消息。如果完整消息不适合用户区域，则将其截断。

返回

返回的消息数据的大小，否则为 errno

int tipc_recvstream(struct socket *sock, struct msghdr *m, size_t buflen, int flags)

接收面向流的数据

参数

struct socket *sock

网络套接字

struct msghdr *m

消息信息描述符

size_t buflen

用户缓冲区区域的总大小

int flags

接收标志

描述

仅用于 SOCK_STREAM 消息。如果没有足够的数据可用，将选择等待更多数据；绝不会截断数据。

返回

返回的消息数据的大小，否则为 errno

void tipc_write_space(struct sock *sk)

如果端口拥塞解除，则唤醒线程

参数

struct sock *sk

套接字

void tipc_data_ready(struct sock *sk)

唤醒线程以指示已接收消息

参数

struct sock *sk

套接字

bool tipc_sk_filter_connect(struct tipc_sock *tsk, struct sk_buff *skb, struct sk_buff_head *xmitq)

检查传入的连接导向套接字消息

参数

struct tipc_sock *tsk

TIPC 套接字

struct sk_buff *skb

指向消息缓冲区的指针。

struct sk_buff_head *xmitq

用于 Nagle ACK（如果有）

返回

如果消息应该添加到接收队列则返回 true，否则返回 false

unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *skb)

获取套接字接收队列的适当过载限制

参数

struct sock *sk

套接字

struct sk_buff *skb

消息

描述

对于面向连接的消息，无论重要性如何，默认队列限制为 2 MB。

对于无连接消息，队列限制基于消息重要性，如下所示

TIPC_LOW_IMPORTANCE (2 MB) TIPC_MEDIUM_IMPORTANCE (4 MB) TIPC_HIGH_IMPORTANCE (8 MB) TIPC_CRITICAL_IMPORTANCE (16 MB)

返回

根据相应的消息重要性设置过载限制

void tipc_sk_filter_rcv(struct sock *sk, struct sk_buff *skb, struct sk_buff_head *xmitq)

验证传入的消息

参数

struct sock *sk

套接字

struct sk_buff *skb

指向消息的指针。

struct sk_buff_head *xmitq

输出消息区域（FIXME）

描述

如果消息可接受，则将其加入接收队列； 对于已连接的套接字，可以选择处理断开连接指示。

调用时已持有套接字锁

int tipc_sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)

处理来自积压队列的传入消息

参数

struct sock *sk

套接字

struct sk_buff *skb

消息

描述

调用者必须持有套接字锁

void tipc_sk_enqueue(struct sk_buff_head *inputq, struct sock *sk, u32 dport, struct sk_buff_head *xmitq)

从 inputq 中提取所有目标为 “dport” 的缓冲区，并尝试将它们添加到套接字或积压队列

参数

struct sk_buff_head *inputq

具有潜在不同目标的传入缓冲区列表

struct sock *sk

应将缓冲区排队的套接字

u32 dport

套接字的端口号

struct sk_buff_head *xmitq

输出队列

描述

调用者必须持有套接字锁

void tipc_sk_rcv(struct net *net, struct sk_buff_head *inputq)

处理传入缓冲区链

参数

struct net *net

关联的网络命名空间。

struct sk_buff_head *inputq

包含缓冲区的缓冲区列表，消耗列表中的所有缓冲区，直到 inputq 为空

注意

可能会在多个线程中调用，这些线程引用同一个队列

int tipc_connect(struct socket *sock, struct sockaddr *dest, int destlen, int flags)

建立与另一个 TIPC 端口的连接

参数

struct socket *sock

套接字结构

struct sockaddr *dest

目标端口的套接字地址

int destlen

套接字地址数据结构的大小

int flags

与套接字关联的文件相关标志

返回

成功时返回 0，否则返回 errno

int tipc_listen(struct socket *sock, int len)

允许套接字侦听传入连接

参数

struct socket *sock

套接字结构

int len

（未使用）

返回

成功时返回 0，否则返回 errno

int tipc_accept(struct socket *sock, struct socket *new_sock, struct proto_accept_arg *arg)

等待连接请求

参数

struct socket *sock

正在侦听的套接字

struct socket *new_sock

要连接的新套接字

struct proto_accept_arg *arg

accept 的参数

返回

成功时返回 0，否则返回 errno

int tipc_shutdown(struct socket *sock, int how)

关闭套接字连接

参数

struct socket *sock

套接字结构

int how

要关闭的方向（必须为 SHUT_RDWR）

描述

终止连接（如有必要），然后清除套接字的接收队列。

返回

成功时返回 0，否则返回 errno

int tipc_setsockopt(struct socket *sock, int lvl, int opt, sockptr_t ov, unsigned int ol)

设置套接字选项

参数

struct socket *sock

套接字结构

int lvl

选项级别

int opt

选项标识符

sockptr_t ov

指向新选项值的指针

unsigned int ol

选项值的长度

描述

仅对于流套接字，接受并忽略所有 IPPROTO_TCP 选项（以方便兼容性）。

返回

成功时返回 0，否则返回 errno

int tipc_getsockopt(struct socket *sock, int lvl, int opt, char __user *ov, int __user *ol)

获取套接字选项

参数

struct socket *sock

套接字结构

int lvl

选项级别

int opt

选项标识符

char __user *ov

选项值的接收器

int __user *ol

选项值长度的接收器

描述

仅对于流套接字，所有 IPPROTO_TCP 选项返回 0 长度结果（以方便兼容性）。

返回

成功时返回 0，否则返回 errno

int tipc_socket_init(void)

初始化 TIPC 套接字接口

参数

void

无参数

返回

成功时返回 0，否则返回 errno

void tipc_socket_stop(void)

停止 TIPC 套接字接口

参数

void

无参数

bool tipc_sk_filtering(struct sock *sk)

检查是否应跟踪套接字

参数

struct sock *sk

要检查的套接字

描述

sysctl_tipc_sk_filter 用作过滤的套接字元组：(portid、套接字类型、名称类型、名称下限、名称上限)

返回

如果套接字满足套接字元组数据（值 0 = ‘any’）或当没有设置元组（all = 0）时返回 true，否则返回 false

bool tipc_sk_overlimit1(struct sock *sk, struct sk_buff *skb)

检查套接字 rx 队列是否即将过载，同时考虑 rcv 和 backlog 队列

参数

struct sock *sk

要检查的 tipc sk

struct sk_buff *skb

要检查的 tipc msg

返回

如果套接字 rx 队列分配 > 90% 则返回 true，否则返回 false

bool tipc_sk_overlimit2(struct sock *sk, struct sk_buff *skb)

检查套接字 rx 队列是否即将过载，仅考虑 rcv 队列

参数

struct sock *sk

要检查的 tipc sk

struct sk_buff *skb

要检查的 tipc msg

返回

如果套接字 rx 队列分配 > 90% 则返回 true，否则返回 false

int tipc_sk_dump(struct sock *sk, u16 dqueues, char *buf)

转储 TIPC 套接字

参数

struct sock *sk

要转储的 tipc sk

u16 dqueues

用于决定是否转储任何套接字队列的位掩码？ - TIPC_DUMP_NONE：不转储套接字队列 - TIPC_DUMP_SK_SNDQ：转储套接字发送队列 - TIPC_DUMP_SK_RCVQ：转储套接字 rcv 队列 - TIPC_DUMP_SK_BKLGQ：转储套接字 backlog 队列 - TIPC_DUMP_ALL：转储以上所有套接字队列

char *buf

以格式返回的转储数据缓冲区

TIPC 网络拓扑接口

bool tipc_sub_check_overlap(struct tipc_service_range *subscribed, struct tipc_service_range *found)

测试给定值的订阅重叠

参数

struct tipc_service_range *subscribed

已订阅的服务范围

struct tipc_service_range *found

我们正在检查匹配的服务范围

描述

如果存在重叠则返回 true，否则返回 false。

TIPC 服务器接口

struct tipc_topsrv

TIPC 服务器结构

定义:

struct tipc_topsrv {
    struct idr conn_idr;
    spinlock_t idr_lock;
    int idr_in_use;
    struct net *net;
    struct work_struct awork;
    struct workqueue_struct *rcv_wq;
    struct workqueue_struct *send_wq;
    struct socket *listener;
    char name[TIPC_SERVER_NAME_LEN];
};

成员

conn_idr

连接的标识符集

idr_lock

保护连接标识符集

idr_in_use

已分配的标识符条目数量

net

网络命名空间实例

awork

接受工作项

rcv_wq

接收工作队列

send_wq

发送工作队列

listener

topsrv 侦听器套接字

name

服务器名称

struct tipc_conn

TIPC 连接结构

定义:

struct tipc_conn {
    struct kref kref;
    int conid;
    struct socket *sock;
    unsigned long flags;
    struct tipc_topsrv *server;
    struct list_head sub_list;
    spinlock_t sub_lock;
    struct work_struct rwork;
    struct list_head outqueue;
    spinlock_t outqueue_lock;
    struct work_struct swork;
};

成员

kref

连接对象的引用计数器

conid

连接标识符

sock

与连接关联的套接字处理程序

标志。

指示连接状态

server

指向已连接服务器的指针

sub_list

lsit 到所有相关的订阅

sub_lock

保护订阅列表的锁

rwork

接收工作项

outqueue

指向队列中第一个出站消息的指针

outqueue_lock

控制对出队列的访问

swork

发送工作项

TIPC 跟踪接口

int tipc_skb_dump(struct sk_buff *skb, bool more, char *buf)

转储 TIPC skb 数据

参数

struct sk_buff *skb

要转储的 skb

bool more

转储更多？- false：仅转储 tipc msg 数据 - true：同时转储内核相关的 skb 数据和 tipc cb[] 数组

char *buf

以格式返回的转储数据缓冲区

int tipc_list_dump(struct sk_buff_head *list, bool more, char *buf)

转储 TIPC skb 列表/队列

参数

struct sk_buff_head *list

要转储的 skb 列表

bool more

转储更多？- false：仅转储 head & tail skbs - true：转储前 5 个和后 5 个 skbs

char *buf

以格式返回的转储数据缓冲区