Linux Netlink通信机制详解（上）

迈不过友情╰ 2022-08-05 14:18 127阅读 0赞

前面有一篇文章其实已经介绍过Netlink方面的知识，还有一个内核和用户空间之间的一个交互例子，这篇文章主要是更细节和基础的知识介绍！

Netlink 是一种特殊的 socket，它是 Linux 所特有的，由于传送的消息是暂存在socket接收缓存中，并不被接收者立即处理，所以netlink是一种异步通信机制。 系统调用和 ioctl 则是同步通信机制。

用户空间进程可以通过标准socket API来实现消息的发送、接收，在Linux中，有很多用户空间和内核空间的交互都是通过Netlink机制完成的，在Linux3.0的内核版本中定义了下面的21个用于Netlink通信的宏，其中默认的最大值为32.我这里重点关注的是IPv6路由部分的通信过程。

在include/linux/\`netlink.h文件中定义了下面的用于通信的宏！

1.  \#define NETLINK\_ROUTE 0 /\* Routing/device hook \*/  
    
2.  \#define NETLINK\_UNUSED 1 /\* Unused number \*/  
    
3.  \#define NETLINK\_USERSOCK 2 /\* Reserved for user mode socket protocols \*/  
    
4.  \#define NETLINK\_FIREWALL 3 /\* Firewalling hook \*/  
    
5.  \#define NETLINK\_INET\_DIAG 4 /\* INET socket monitoring \*/  
    
6.  \#define NETLINK\_NFLOG 5 /\* netfilter/iptables ULOG \*/  
    
7.  \#define NETLINK\_XFRM 6 /\* ipsec \*/  
    
8.  \#define NETLINK\_SELINUX 7 /\* SELinux event notifications \*/  
    
9.  \#define NETLINK\_ISCSI 8 /\* Open\-iSCSI \*/  
    
10. \#define NETLINK\_AUDIT 9 /\* auditing \*/  
    
11. \#define NETLINK\_FIB\_LOOKUP 10  
    
12. \#define NETLINK\_CONNECTOR 11  
    
13. \#define NETLINK\_NETFILTER 12 /\* netfilter subsystem \*/  
    
14. \#define NETLINK\_IP6\_FW 13  
    
15. \#define NETLINK\_DNRTMSG 14 /\* DECnet routing messages \*/  
    
16. \#define NETLINK\_KOBJECT\_UEVENT 15 /\* Kernel messages to userspace \*/  
    
17. \#define NETLINK\_GENERIC 16  
    
18. /\* leave room for NETLINK\_DM (DM Events) \*/  
    
19. \#define NETLINK\_SCSITRANSPORT 18 /\* SCSI Transports \*/  
    
20. \#define NETLINK\_ECRYPTFS 19  
    
21. \#define NETLINK\_RDMA 20  
    
22.   
    
23. \#define MAX\_LINKS 32

用户态可以使用标准的socket APIs， socket(), bind(), sendmsg(), recvmsg() 和 close() 等函数就能很容易地使用netlink socket，我们在用户空间可以直接通过socket函数来使用Netlink通信，例如可以通过下面的方式：

1.  sock = socket  (AF\_NETLINK, SOCK\_RAW, NETLINK\_ROUTE);

说明：第一个参数必须是AF\_NETLINK 或 PF\_NETLINK，在 Linux 中，它们俩实际为一个东西，它表示要使用netlink，第二个参数必须是SOCK\_RAW或SOCK\_DGRAM，第三个参数指定netlink协议类型，可以是自己在netlink.h中定义的，也可以是内核中已经定义好的。上面的例子使用主要是路由的Netlink协议。也可以是上面21中协议类型的其中之一。

NETLINK\_GENERIC是一个通用的协议类型，它是专门为用户使用的，因此，用户可以直接使用它，而不必再添加新的协议类型。

对于每一个netlink协议类型，可以使用多播的概念，最多可以有 32个多播组，每一个多播组用一个位表示，netlink 的多播特性使得发送消息给同一个组仅需要一次系统调用，因而对于需要多播消息的应用而言，大大地降低了系统调用的次数。

下面介绍一下主要的数据结构：

1.  struct sockaddr\_nl \{   
    
2.  sa\_family\_t nl\_family; /\* AF\_NETLINK \*/  
    
3.  unsigned short nl\_pad; /\* zero \*/  
    
4.  \_\_u32 nl\_pid; /\* port ID \*/  
    
5.  \_\_u32 nl\_groups; /\* multicast groups mask \*/  
    
6.  \};

说明：（1） sa\_family\_t nl\_family;

一般为AF\_NETLINK，

（2） unsigned short nl\_pad;

字段 nl\_pad 当前没有使用，因此要总是设置为 0，

（3）\_\_u32 nl\_pid;

绑定时用于指定绑定者的进程号，发送消息时用于指定接收进程号，如果希望内核处理多播消息，就把该字段设置为 0，否则设置为处理消息的进程 ID。传递给 bind 函数的地址的 nl\_pid 字段应当设置为本进程的进程 ID，这相当于 netlink socket 的本地地址。但是，对于一个netlink socket 的情况，字段 nl\_pid 则可以设置为其它的值，如：

pthread\_self()<< 16 | getpid();

因此字段 nl\_pid 实际上未必是进程 ID,它只是用于区分不同的接收者或发送者的一个标识，用户可以根据自己需要设置该字段。

（4） \_\_u32 nl\_groups;

绑定时用于指定绑定者所要加入的多播组，这样绑定者就可以接收多播消息，发送 消息时可以用于指定多播组，这样就可以将消息发给多个接收者。这里nl\_groups 为32位的无符号整形，所以可以指定32个多播组，每个进程可以加入多个多播组， 因为多播组是通过“或”操作，如果设置为 0，表示调用者不加入任何多播组。这里就是Netlink多播的概念！和通信中的多播概念有点类似。

Bind的调用方式如下！

1.  struct sockaddr\_nl snl;  
    
2.  memset (&snl, 0, sizeof snl);  
    
3.  snl.nl\_family  = AF\_NETLINK;  
    
4.  snl.nl\_groups  = groups;  
    
5.  ret = bind (sock, (struct sockaddr \*) &snl, sizeof snl);

其中sock为前面的 socket 调用返回的文件描述符，参数snl为 structsockaddr\_nl 类型的地址。为了发送一个 netlink 消息给内核或其他用户态应用，需要填充目标 netlink socket 地址，此时，字段 nl\_pid 和 nl\_groups 分别表示接收消息者的进程 ID 与多播组。如果字段 nl\_pid 设置为 0，表示消息接收者为内核或多播组，如果 nl\_groups为 0，表示该消息为单播消息，否则表示多播消息。用户态使用函数 sendmsg 发送 netlink 消息时还需要引用结构 struct msghdr、struct nlmsghdr 和 struct iovec，结构 struct msghdr 的定义如下：

1.  struct msghdr \{   
    
2.  void \* msg\_name; /\* Socket name \*/  
    
3.  int msg\_namelen; /\* Length of name \*/  
    
4.  struct iovec \* msg\_iov; /\* Data blocks \*/  
    
5.  \_\_kernel\_size\_t msg\_iovlen; /\* Number of blocks \*/  
    
6.  void \* msg\_control; /\* Per protocol magic (eg BSD file descriptor passing) \*/  
    
7.  \_\_kernel\_size\_t msg\_controllen; /\* Length of cmsg list \*/  
    
8.  unsigned msg\_flags;  
    
9.  \};

使用方法如下：

1.  struct msghdr msg;  
    
2.  memset(&msg, 0, sizeof(msg));  
    
3.  msg.msg\_name = (void \*)&(snl);  
    
4.  msg.msg\_namelen  = sizeof(snl);

struct nlmsghdr 为 netlink socket 自己的消息头，因此它也被称为netlink 控制块。应用层在向内核发送 netlink 消息时必须提供该控制头。

消息头。

1.  struct nlmsghdr  
    
2.  \{   
    
3.  \_\_u32 nlmsg\_len; /\* Length of message including header \*/  
    
4.  \_\_u16 nlmsg\_type; /\* Message content \*/  
    
5.  \_\_u16 nlmsg\_flags; /\* Additional flags \*/  
    
6.  \_\_u32 nlmsg\_seq; /\* Sequence number \*/  
    
7.  \_\_u32 nlmsg\_pid; /\* Sending process PID \*/  
    
8.  \};

字段 nlmsg\_len 指定消息的总长度，包括紧跟该结构的数据部分长度以及该结构的大小，字段 nlmsg\_type 用于应用内部定义消息的类型，它对netlink 内核实现是透明的，因此大部分情况下设置为 0，字段 nlmsg\_seq 和 nlmsg\_pid 用于应用追踪消息，前者表示顺序号，后者为消息来源进程 ID。字段 nlmsg\_flags 用于设置消息标志，可用的标志包括下面的宏定义：kernel/include/linux/netlink.c

1.  /\* Flags values \*/  
    
2.    
    
3.  \#define NLM\_F\_REQUEST 1 /\* It is request message. \*/  
    
4.  \#define NLM\_F\_MULTI 2 /\* Multipart message, terminated by NLMSG\_DONE \*/  
    
5.  \#define NLM\_F\_ACK 4 /\* Reply with ack, with zero or error code \*/  
    
6.  \#define NLM\_F\_ECHO 8 /\* Echo this request \*/  
    
7.    
    
8.  /\* Modifiers to GET request \*/  
    
9.  \#define NLM\_F\_ROOT 0x100 /\* specify tree root \*/  
    
10. \#define NLM\_F\_MATCH 0x200 /\* return all matching \*/  
    
11. \#define NLM\_F\_ATOMIC 0x400 /\* atomic GET \*/  
    
12. \#define NLM\_F\_DUMP (NLM\_F\_ROOT|NLM\_F\_MATCH)  
    
13.   
    
14. /\* Modifiers to NEW request \*/  
    
15. \#define NLM\_F\_REPLACE 0x100 /\* Override existing \*/  
    
16. \#define NLM\_F\_EXCL 0x200 /\* Do not touch, if it exists \*/  
    
17. \#define NLM\_F\_CREATE 0x400 /\* Create, if it does not exist \*/  
    
18. \#define NLM\_F\_APPEND 0x800 /\* Add to end of list \*/

标志NLM\_F\_REQUEST用于表示消息是一个请求，所有应用首先发起的消息都应设置该标志。

标志NLM\_F\_MULTI用于指示该消息是一个多部分消息的一部分，后续的消息可以通过宏NLMSG\_NEXT来获得。

宏NLM\_F\_ACK表示该消息是前一个请求消息的响应，顺序号与进程ID可以把请求与响应关联起来。

标志NLM\_F\_ECHO表示该消息是相关的一个包的回传。

标志NLM\_F\_ROOT 被许多 netlink 协议的各种数据获取操作使用，该标志指示被请求的数据表应当整体返回用户应用，而不是一个条目一个条

地返回。有该标志的请求通常导致响应消息设置 NLM\_F\_MULTI标志。注意，当设置了该标志时，请求是协议特定的，因此，需要在字段

nlmsg\_type 中指定协议类型。

标志NLM\_F\_MATCH 表示该协议特定的请求只需要一个数据子集，数据子集由指定的协议特定的过滤器来匹配。

标志NLM\_F\_ATOMIC 指示请求返回的数据应当原子地收集，这预防数据在获取期间被修改。

标志 NLM\_F\_DUMP未实现。

标志NLM\_F\_REPLACE 用于取代在数据表中的现有条目。

标志NLM\_F\_EXCL\_ 用于和 CREATE 和 APPEND 配合使用，如果条目已经存在，将失败。

标志NLM\_F\_CREATE 指示应当在指定的表中创建一个条目。

标志NLM\_F\_APPEND 指示在表末尾添加新的条目。

内核需要读取和修改这些标志，对于一般的使用，用户把它设置为 0 就可以，只是一些高级应用（如 netfilter 和路由 daemon 需要它进行一些设置），

下面是在调用sendmsg函数之前的各个结构体的赋值操作：

1.  struct nlmsghdr \*n  
    
2.  struct iovec iov =  \{  (void\*) n, n\->nlmsg\_len \};  
    
3.  struct msghdr msg =  \{ (void\*) &snl, sizeof snl, &iov, 1, NULL, 0, 0\};

其中snl为 struct sockaddr\_nl snl;在结构体structmsghdr中包含有struct iovec结构，其实就是我们要传输的数据块，它为一个指针，定义了数据块的基址和长度。

1.  struct iovec  
    
2.  \{   
    
3.  void \_\_user \*iov\_base; /\* BSD uses caddr\_t (1003.1g requires void \*)  \*/  
    
4.  \_\_kernel\_size\_t iov\_len;  /\* Must be size\_t  (1003.1g) \*/  
    
5.  \};

上面的数据结构全部初始化以后就可以调用sendmsg函数进行发送操作了。

1.  status = sendmsg (sock,  &msg, 0);

其中sock就是我们创建的sock套接字，msg就是上面结构体structmsghdr的实例。如果我们需要返回一个ACK消息，可以对flags标志进行设置如下：

1.  /\* Request an acknowledgement by setting NLM\_F\_ACK \*/  
    
2.  n\->nlmsg\_flags |= NLM\_F\_ACK;

使用下面的函数进行接收处理时，status;为返回的状态，这里可能的结果为：

1.  \#define NLMSG\_NOOP 0x1 /\* Nothing. \*/  
    
2.  \#define NLMSG\_ERROR 0x2 /\* Error \*/  
    
3.  \#define NLMSG\_DONE 0x3 /\* End of a dump \*/  
    
4.  \#define NLMSG\_OVERRUN 0x4 /\* Data lost  
    
5.  int status;  
    
6.  char buf\[4096\];  
    
7.  struct iovec iov =  \{  buf, sizeof buf  \};  
    
8.  struct sockaddr\_nl snl;  
    
9.  struct msghdr msg =  \{  (void\*)&snl, sizeof snl, &iov, 1, NULL, 0, 0\};  
    
10. struct nlmsghdr \*h;  
    
11. status = recvmsg  (sock, &msg, 0);

在linux/netlink.h中定义了一些方便对消息进行处理的宏，这些宏包括：

\#define NLMSG\_ALIGNTO 4

\#define NLMSG\_ALIGN(len) ( ((len)+NLMSG\_ALIGNTO-1) &~(NLMSG\_ALIGNTO-1) )

/\*宏NLMSG\_ALIGN(len)用于得到不小于len且字节对齐的最小数值\*/

\#define NLMSG\_HDRLEN ((int) NLMSG\_ALIGN(sizeof(struct nlmsghdr)))

\#define NLMSG\_LENGTH(len) ((len)+NLMSG\_ALIGN(NLMSG\_HDRLEN))

/\*宏NLMSG\_LENGTH(len)用于计算数据部分长度为len时实际的消息长度。它一般用于分配消息缓存\*/

\#define NLMSG\_SPACE(len) NLMSG\_ALIGN(NLMSG\_LENGTH(len))

/\*宏NLMSG\_SPACE(len)返回不小于NLMSG\_LENGTH(len)且字节对齐的最小数值，它也用于分配消息缓存\*/

\#define NLMSG\_DATA(nlh) ((void\*)(((char\*)nlh) + NLMSG\_LENGTH(0)))

/\*宏NLMSG\_DATA(nlh)用于取得消息的数据部分的首地址，设置和读取消息数据部分时需要使用该宏\*/

\#define NLMSG\_NEXT(nlh,len) ((len) -= NLMSG\_ALIGN((nlh)->nlmsg\_len), \\

(struct nlmsghdr\*)(((char\*)(nlh)) +NLMSG\_ALIGN((nlh)->nlmsg\_len)))

/\*宏NLMSG\_NEXT(nlh,len)用于得到下一个消息的首地址，同时len也减少为剩余消息的总长度，该宏一般在一个消息被分成几个部分发送或接收时使用\*/

\#define NLMSG\_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr)&& \\

(nlh)->nlmsg\_len >= sizeof(structnlmsghdr) && \\

(nlh)->nlmsg\_len <= (len))

/\*宏NLMSG\_OK(nlh,len)用于判断消息是否有len这么长\*/

\#define NLMSG\_PAYLOAD(nlh,len) ((nlh)->nlmsg\_len -NLMSG\_SPACE((len)))

/\*宏NLMSG\_PAYLOAD(nlh,len)用于返回payload的长度\*/

在/kernel/net/netlink/af\_netlink.c文件中定义了netlink套接字的结构体，

1.  struct netlink\_sock \{   
    
2.  /\* struct sock has to be the first member of netlink\_sock  \*/  
    
3.  struct sock sk;  
    
4.  u32 pid;  //内核自己的pid，=0  
    
5.  u32 dst\_pid;  
    
6.  u32 dst\_group;//目的组  
    
7.  u32 flags;  
    
8.  u32 subscriptions;  
    
9.  u32 ngroups;// 组数量  
    
10. unsigned long \*groups; //组号  
    
11. unsigned long state;  
    
12. wait\_queue\_head\_t wait;// 进程在接收数据包时等待队列  
    
13. struct netlink\_callback \*cb;  
    
14. spinlock\_t cb\_lock;  
    
15. void (\*data\_ready)(struct sock \*sk,  int bytes); ///内核态接收到用户态信息后的处理函数  
    
16. struct module \*module;  
    
17. \};

在af\_netlink.c文件中我们可以看到netlink协议的注册

1.  static struct proto netlink\_proto  = \{   
    
2.  .name  = "NETLINK",  
    
3.  .owner  = THIS\_MODULE,  
    
4.  .obj\_size  = sizeof(struct netlink\_sock),  
    
5.  \};

在static int\_\_init netlink\_proto\_init(void)函数中会调用注册协议的函数，对netlink协议进行注册，其中，netlink\_proto就是上面的struct proto netlink\_proto协议。

1.  int  err = proto\_register(&netlink\_proto, 0);

在内核中接收的数据和存储发送的数据都是放在了skb\_buff的结构体中

1.  struct netlink\_skb\_parms  
    
2.  \{   
    
3.  struct ucred creds; /\* Skb credentials \*/  
    
4.  \_\_u32 pid;  
    
5.  \_\_u32 dst\_pid;  
    
6.  \_\_u32 dst\_group;  
    
7.  kernel\_cap\_t eff\_cap;  
    
8.  \_\_u32 loginuid; /\* Login (audit) uid \*/  
    
9.  \};

使用下面的宏获取skb\_bff中的数据部分

1.  \#define NETLINK\_CB(skb) (\*(struct netlink\_skb\_parms\*)&((skb)\->cb))