Linux Kernel TIPC

简介

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

TIPC 特性

  • 集群范围的 IPC 服务

    您是否曾经希望拥有 Unix 域套接字的便利性，即使在集群节点之间传输数据时也是如此？您可以自己确定要绑定的和使用的地址？您不必执行 DNS 查找并担心 IP 地址？您不必启动计时器来监视对等套接字的持续存在？但又没有该套接字类型的缺点，例如 lingering inodes 的风险？

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

  • 服务寻址

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

  • 服务跟踪

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

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

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

  • 传输模式

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

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

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

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

  • 节点间链路

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

  • 集群可扩展性

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

  • 邻居发现

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

  • 配置

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

  • 性能

    TIPC 消息传输延迟时间优于任何其他已知协议。节点间连接的最大字节吞吐量仍然略低于 TCP，而同一主机上的节点内和容器间吞吐量则优于 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

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

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

成员

rcu

用于延迟释放的 RCU 回调头

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 > threshold 则使用广播

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

适用的网络命名空间

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

适用的网络命名空间

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

适用的网络命名空间

struct tipc_bearer *b

目标承载

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

禁用此承载

参数

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

成员

proto

正在使用的以太网协议

port

正在使用的端口

{unnamed_union}

anonymous

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

成员

bearer

关联的通用 tipc 承载

ubsock

承载关联的套接字

ifindex

本地地址范围

work

用于在承载上计划延迟工作

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 列表中一个条目的 per-cpu 指针

加密

TIPC 加密拥有此密钥

克隆

克隆情况下引用源密钥

用户

密钥用户数（TX/RX）

salt

密钥的 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 加密的通用工作队列

work

TX/RX 的延迟工作调度

key_distr

密钥分发状态

rekeying_intv

重新密钥间隔（分钟）

stats

加密统计信息

name

加密名称

sndnxt

每个对等方的 sndnxt (TX)

timer1

通用计时器 1 (jiffies)

timer2

通用计时器 2 (jiffies)

{unnamed_union}

anonymous

{unnamed_struct}

anonymous

working

加密是否正在工作

key_master

标志指示主密钥是否存在

legacy_user

标志指示对等方是否在没有主密钥的情况下加入（用于 bwd comp.）

nokey

无密钥指示

flags

组合标志字段

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 密钥数据的“副本”复制到目标，TFMs 列表对于密钥是通用的。源的引用保存在“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

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

net 结构

struct tipc_aead_key *skey

要发送的会话密钥

u16 gen

密钥的生成

u8 mode

密钥的模式

u32 dnode

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

描述

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

返回

成功时为 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

适用的网络命名空间

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

适用的 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

适用的网络命名空间

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

适用的网络命名空间

struct tipc_bearer *b

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

TIPC msg 接口

struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp)

创建 TIPC 消息缓冲区

参数

u32 size

消息大小（包括 TIPC 标头）

gfp_t gfp

内存分配标志

返回

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

注意

预留了 headroom 以允许添加数据链路标头。缓冲区的末尾可能还存在未请求的 tailroom。

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

分段消息的缓冲区偏移量 (FIXME)

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 树的成员

max

此节点子树中最大的“upper”

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

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

subscriptions

此服务类型的订阅列表

lock

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

rcu

用于延迟释放的 RCU 回调头

service_range_foreach_match

service_range_foreach_match (sr, sc, start, end)

对于每个范围匹配，迭代 tipc 服务 rbtree

参数

sr

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

sc

指向 tipc 服务的指针，该服务拥有服务范围 rbtree

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

从中删除发布的 service_range

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 + payload 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

在此处存储上次收到的 seqno

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

控制结构访问的 rwlock

net

适用的网络命名空间

哈希

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

active_links

活动链接的承载 ID，用作 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 struct

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

注意

必须首先持有节点 ref 计数器！

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

适用的网络命名空间

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

适用的网络命名空间

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

适用的网络命名空间

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

适用的网络命名空间

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

在 backlog 和 rcv 队列中重复计算的字节数

conn_timeout

我们可以等待未响应的设置请求的时间

probe_unacked

探测尚未收到 ack

cong_link_cnt

拥塞链接数

snt_unacked

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

snd_win

发送窗口大小

peer_caps

对等方功能掩码

rcv_unacked

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

rcv_win

接收窗口大小

peer

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

节点

哈希表节点

mc_method

套接字和广播层之间使用的 Cookie

rcu

tipc_sock 的 rcu struct

group

TIPC 通信组

oneway

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

nagle_start

当前 nagle 值

snd_backlog

发送 backlog 计数

msg_acc

已接受的消息；用于管理 backlog 和 nagle

pkt_cnt

TIPC 套接字数据包计数

expect_ack

此 TIPC 套接字是否期望收到 ack

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 并在 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

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

接受的参数

返回

成功时为 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 用作过滤的套接字元组：（端口 ID、套接字类型、名称类型、名称下限、名称上限）

返回

如果套接字满足套接字元组数据（值 0 = “任何”）或没有元组集（全部 = 0），则为 true，否则为 false

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

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

参数

struct sock *sk

要检查的 tipc sk

struct sk_buff *skb

要检查的 tipc 消息

返回

如果套接字 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 消息

返回

如果套接字 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：转储套接字接收队列 - TIPC_DUMP_SK_BKLGQ：转储套接字积压队列 - 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

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

flags

指示连接状态

server

指向已连接服务器的指针

sub_list

lsit 到所有相关的订阅

sub_lock

保护订阅列表的锁

rwork

接收工作项

outqueue

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

outqueue_lock

控制对 outqueue 的访问

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：仅转储头部和尾部 skb - true：转储前 5 个和后 5 个 skb

char *buf

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