Linux 用户态与内核态的交互——netlink 篇

「爱情、让人受尽委屈。」 2022-08-24 04:16 291阅读 0赞

这是一篇学习笔记，主要是对《Linux 系统内核空间与用户空间通信的实现与分析》中的源码imp2的分析。其中的源码，可以到以下URL下载：  
http://www-128.ibm.com/developerworks/cn/linux/l-netlink/imp2.tar.gz  
  
参考文档  
《Linux 系统内核空间与用户空间通信的实现与分析》 陈鑫  
http://www-128.ibm.com/developerworks/cn/linux/l-netlink/?ca=dwcn-newsletter-linux  
《在 Linux 下用户空间与内核空间数据交换的方式》 杨燚  
http://www-128.ibm.com/developerworks/cn/linux/l-kerns-usrs/  
  
理论篇  
在 Linux 2.4 版以后版本的内核中，几乎全部的中断过程与用户态进程的通信都是使用 netlink 套接字实现的，例如iprote2网络管理工具，它与内核的交互就全部使用了netlink，著名的内核包过滤框架Netfilter在与用户空间的通读，也在最新版本中改变为netlink，无疑，它将是Linux用户态与内核态交流的主要方法之一。它的通信依据是一个对应于进程的标识，一般定为该进程的 ID。当通信的一端处于中断过程时，该标识为 0。当使用 netlink 套接字进行通信，通信的双方都是用户态进程，则使用方法类似于消息队列。但通信双方有一端是中断过程，使用方法则不同。netlink 套接字的最大特点是对中断过程的支持，它在内核空间接收用户空间数据时不再需要用户自行启动一个内核线程，而是通过另一个软中断调用用户事先指定的接收函数。工作原理如图：  
  
![image003.gif][]  
  
如图所示，这里使用了软中断而不是内核线程来接收数据，这样就可以保证数据接收的实时性。  
当 netlink 套接字用于内核空间与用户空间的通信时，在用户空间的创建方法和一般套接字使用类似，但内核空间的创建方法则不同，下图是 netlink 套接字实现此类通信时创建的过程：  
  
![image004.gif][]  
  
用户空间  
  
用户态应用使用标准的socket与内核通讯，标准的socket API 的函数， socket(), bind(), sendmsg(), recvmsg() 和 close()很容易地应用到 netlink socket。  
为了创建一个 netlink socket，用户需要使用如下参数调用 socket():

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

socket(AF\_NETLINK, SOCK\_RAW, netlink\_type)

netlink对应的协议簇是 AF\_NETLINK，第二个参数必须是SOCK\_RAW或SOCK\_DGRAM， 第三个参数指定netlink协议类型，它可以是一个自定义的类型，也可以使用内核预定义的类型：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

\#define NETLINK\_ROUTE 0 /\* Routing/device hook \*/  
\#define NETLINK\_W1 1 /\* 1-wire subsystem \*/  
\#define NETLINK\_USERSOCK 2 /\* Reserved for user mode socket protocols \*/  
\#define NETLINK\_FIREWALL 3 /\* Firewalling hook \*/  
\#define NETLINK\_INET\_DIAG 4 /\* INET socket monitoring \*/  
\#define NETLINK\_NFLOG 5 /\* netfilter/iptables ULOG \*/  
\#define NETLINK\_XFRM 6 /\* ipsec \*/  
\#define NETLINK\_SELINUX 7 /\* SELinux event notifications \*/  
\#define NETLINK\_ISCSI 8 /\* Open-iSCSI \*/  
\#define NETLINK\_AUDIT 9 /\* auditing \*/  
\#define NETLINK\_FIB\_LOOKUP 10  
\#define NETLINK\_CONNECTOR 11  
\#define NETLINK\_NETFILTER 12 /\* netfilter subsystem \*/  
\#define NETLINK\_IP6\_FW 13  
\#define NETLINK\_DNRTMSG 14 /\* DECnet routing messages \*/  
\#define NETLINK\_KOBJECT\_UEVENT 15 /\* Kernel messages to userspace \*/

\#define NETLINK\_GENERIC 16  
  
同样地，socket函数返回的套接字，可以交给bing等函数调用：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

static int skfd;  
skfd = socket(PF\_NETLINK, SOCK\_RAW, NL\_IMP2);  
if(skfd < 0)  
\{  
printf("can not create a netlink socket/n");  
exit(0);  
\}

bind函数需要绑定协议地址，netlink的socket地址使用struct sockaddr\_nl结构描述：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct sockaddr\_nl  
\{  
sa\_family\_t nl\_family;  
unsigned short nl\_pad;  
\_\_u32 nl\_pid;  
\_\_u32 nl\_groups;  
\};

成员 nl\_family为协议簇 AF\_NETLINK，成员 nl\_pad 当前没有使用，因此要总是设置为 0，成员 nl\_pid 为接收或发送消息的进程的 ID，如果希望内核处理消息或多播消息，就把该字段设置为 0，否则设置为处理消息的进程 ID。成员 nl\_groups 用于指定多播组，bind 函数用于把调用进程加入到该字段指定的多播组，如果设置为 0，表示调用者不加入任何多播组：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct sockaddr\_nl local;  
  
memset(&local, 0, sizeof(local));  
local.nl\_family = AF\_NETLINK;  
local.nl\_pid = getpid(); /\*设置pid为自己的pid值\*/  
local.nl\_groups = 0;  
/\*绑定套接字\*/  
if(bind(skfd, (struct sockaddr\*)&local, sizeof(local)) != 0)  
\{  
printf("bind() error/n");  
return -1;  
\}

用户空间可以调用send函数簇向内核发送消息，如sendto、sendmsg等，同样地，也可以使用struct sockaddr\_nl来描述一个对端地址，以待send函数来调用，与本地地址稍不同的是，因为对端为内核，所以nl\_pid成员需要设置为0：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct sockaddr\_nl kpeer;  
memset(&kpeer, 0, sizeof(kpeer));  
kpeer.nl\_family = AF\_NETLINK;  
kpeer.nl\_pid = 0;  
kpeer.nl\_groups = 0;

另一个问题就是发内核发送的消息的组成，使用我们发送一个IP网络数据包的话，则数据包结构为“IP包头+IP数据”，同样地，netlink的消息结构是“netlink消息头部+数据”。Netlink消息头部使用struct nlmsghdr结构来描述：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct nlmsghdr  
\{  
\_\_u32 nlmsg\_len; /\* Length of message \*/  
\_\_u16 nlmsg\_type; /\* Message type\*/  
\_\_u16 nlmsg\_flags; /\* Additional flags \*/  
\_\_u32 nlmsg\_seq; /\* Sequence number \*/  
\_\_u32 nlmsg\_pid; /\* Sending process PID \*/  
\};

字段 nlmsg\_len 指定消息的总长度，包括紧跟该结构的数据部分长度以及该结构的大小，一般地，我们使用netlink提供的宏NLMSG\_LENGTH来计算这个长度，仅需向NLMSG\_LENGTH宏提供要发送的数据的长度，它会自动计算对齐后的总长度：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

/\*计算包含报头的数据报长度\*/  
\#define NLMSG\_LENGTH(len) ((len)+NLMSG\_ALIGN(sizeof(struct nlmsghdr)))  
/\*字节对齐\*/  
\#define NLMSG\_ALIGN(len) ( ((len)+NLMSG\_ALIGNTO-1) & ~(NLMSG\_ALIGNTO-1) )

后面还可以看到很多netlink提供的宏，这些宏可以为我们编写netlink宏提供很大的方便。  
  
字段 nlmsg\_type 用于应用内部定义消息的类型，它对 netlink 内核实现是透明的，因此大部分情况下设置为 0，字段 nlmsg\_flags 用于设置消息标志，对于一般的使用，用户把它设置为 0 就可以，只是一些高级应用（如 netfilter 和路由 daemon 需要它进行一些复杂的操作），字段 nlmsg\_seq 和 nlmsg\_pid 用于应用追踪消息，前者表示顺序号，后者为消息来源进程 ID。

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct msg\_to\_kernel /\*自定义消息首部，它仅包含了netlink的消息首部\*/  
\{  
struct nlmsghdr hdr;  
\};  
  
struct msg\_to\_kernel message;  
memset(&message, 0, sizeof(message));  
message.hdr.nlmsg\_len = NLMSG\_LENGTH(0); /\*计算消息，因为这里只是发送一个请求消息，没有多余的数据，所以，数据长度为0\*/  
message.hdr.nlmsg\_flags = 0;  
message.hdr.nlmsg\_type = IMP2\_U\_PID; /\*设置自定义消息类型\*/  
message.hdr.nlmsg\_pid = local.nl\_pid; /\*设置发送者的PID\*/  
  
这样，有了本地地址、对端地址和发送的数据，就可以调用发送函数将消息发送给内核了：  
/\*发送一个请求\*/  
sendto(skfd, &message, message.hdr.nlmsg\_len, 0,  
(struct sockaddr\*)&kpeer, sizeof(kpeer));

当发送完请求后，就可以调用recv函数簇从内核接收数据了，接收到的数据包含了netlink消息首部和要传输的数据：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

/\*接收的数据包含了netlink消息首部和自定义数据结构\*/  
struct u\_packet\_info  
\{  
struct nlmsghdr hdr;  
struct packet\_info icmp\_info;  
\};  
struct u\_packet\_info info;  
while(1)  
\{  
kpeerlen = sizeof(struct sockaddr\_nl);  
/\*接收内核空间返回的数据\*/  
rcvlen = recvfrom(skfd, &info, sizeof(struct u\_packet\_info),  
0, (struct sockaddr\*)&kpeer, &kpeerlen);  
  
/\*处理接收到的数据\*/  
……  
\}

同样地，函数close用于关闭打开的netlink socket。程序中，因为程序一直循环接收处理内核的消息，需要收到用户的关闭信号才会退出，所以关闭套接字的工作放在了自定义的信号函数sig\_int中处理：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

/\*这个信号函数，处理一些程序退出时的动作\*/  
static void sig\_int(int signo)  
\{  
struct sockaddr\_nl kpeer;  
struct msg\_to\_kernel message;  
  
memset(&kpeer, 0, sizeof(kpeer));  
kpeer.nl\_family = AF\_NETLINK;  
kpeer.nl\_pid = 0;  
kpeer.nl\_groups = 0;  
  
memset(&message, 0, sizeof(message));  
message.hdr.nlmsg\_len = NLMSG\_LENGTH(0);  
message.hdr.nlmsg\_flags = 0;  
message.hdr.nlmsg\_type = IMP2\_CLOSE;  
message.hdr.nlmsg\_pid = getpid();  
  
/\*向内核发送一个消息，由nlmsg\_type表明，应用程序将关闭\*/  
sendto(skfd, &message, message.hdr.nlmsg\_len, 0, (struct sockaddr \*)(&kpeer), sizeof(kpeer));  
  
close(skfd);  
exit(0);  
\}

这个结束函数中，向内核发送一个“我已经退出了”的消息，然后调用close函数关闭netlink套接字，退出程序。  
  
内核空间  
  
与应用程序内核，内核空间也主要完成三件工作：  
n 创建netlink套接字  
n 接收处理用户空间发送的数据  
n 发送数据至用户空间  
  
API函数netlink\_kernel\_create用于创建一个netlink socket，同时，注册一个回调函数，用于接收处理用户空间的消息：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

struct sock \*  
netlink\_kernel\_create(int unit, void (\*input)(struct sock \*sk, int len));

参数unit表示netlink协议类型，如NL\_IMP2，参数input则为内核模块定义的netlink消息处理函数，当有消息到达这个netlink socket时，该input函数指针就会被引用。函数指针input的参数sk实际上就是函数netlink\_kernel\_create返回的struct sock指针，sock实际是socket的一个内核表示数据结构，用户态应用创建的socket在内核中也会有一个struct sock结构来表示。

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

static int \_\_init init(void)  
\{  
rwlock\_init(&user\_proc.lock); /\*初始化读写锁\*/  
  
/\*创建一个netlink socket，协议类型是自定义的ML\_IMP2，kernel\_reveive为接受处理函数\*/  
nlfd = netlink\_kernel\_create(NL\_IMP2, kernel\_receive);  
if(!nlfd) /\*创建失败\*/  
\{  
printk("can not create a netlink socket/n");  
return -1;  
\}  
  
/\*注册一个Netfilter 钩子\*/  
return nf\_register\_hook(&imp2\_ops);  
\}  
  
  
module\_init(init);

用户空间向内核发送了两种自定义消息类型：IMP2\_U\_PID和IMP2\_CLOSE，分别是请求和关闭。kernel\_receive 函数分别处理这两种消息：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

DECLARE\_MUTEX(receive\_sem); /\*初始化信号量\*/  
static void kernel\_receive(struct sock \*sk, int len)  
\{  
do  
\{  
struct sk\_buff \*skb;  
if(down\_trylock(&receive\_sem)) /\*获取信号量\*/  
return;  
/\*从接收队列中取得skb，然后进行一些基本的长度的合法性校验\*/  
while((skb = skb\_dequeue(&sk->receive\_queue)) != NULL)  
\{  
\{  
struct nlmsghdr \*nlh = NULL;  
  
if(skb->len >= sizeof(struct nlmsghdr))  
\{  
/\*获取数据中的nlmsghdr 结构的报头\*/  
nlh = (struct nlmsghdr \*)skb->data;  
if((nlh->nlmsg\_len >= sizeof(struct nlmsghdr))  
&& (skb->len >= nlh->nlmsg\_len))  
\{  
/\*长度的全法性校验完成后，处理应用程序自定义消息类型，主要是对用户PID的保存，即为内核保存“把消息发送给谁”\*/  
if(nlh->nlmsg\_type == IMP2\_U\_PID) /\*请求\*/  
\{  
write\_lock\_bh(&user\_proc.pid);  
user\_proc.pid = nlh->nlmsg\_pid;  
write\_unlock\_bh(&user\_proc.pid);  
\}  
else if(nlh->nlmsg\_type == IMP2\_CLOSE) /\*应用程序关闭\*/  
\{  
write\_lock\_bh(&user\_proc.pid);  
if(nlh->nlmsg\_pid == user\_proc.pid)  
user\_proc.pid = 0;  
write\_unlock\_bh(&user\_proc.pid);  
\}  
\}  
\}  
\}  
kfree\_skb(skb);  
\}  
up(&receive\_sem); /\*返回信号量\*/  
\}while(nlfd && nlfd->receive\_queue.qlen);  
\}

因为内核模块可能同时被多个进程同时调用，所以函数中使用了信号量和锁来进行互斥。skb = skb\_dequeue(&sk->receive\_queue)用于取得socket sk的接收队列上的消息，返回为一个struct sk\_buff的结构，skb->data指向实际的netlink消息。  
  
程序中注册了一个Netfilter钩子，钩子函数是get\_icmp，它截获ICMP数据包，然后调用send\_to\_user函数将数据发送给应用空间进程。发送的数据是info结构变量，它是struct packet\_info结构，这个结构包含了来源/目的地址两个成员。Netfilter Hook不是本文描述的重点，略过。  
send\_to\_user 用于将数据发送给用户空间进程，发送调用的是API函数netlink\_unicast 完成的：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

int netlink\_unicast(struct sock \*sk, struct sk\_buff \*skb, u32 pid, int nonblock);

参数sk为函数netlink\_kernel\_create()返回的套接字，参数skb存放待发送的消息，它的data字段指向要发送的netlink消息结构，而skb的控制块保存了消息的地址信息， 参数pid为接收消息进程的pid，参数nonblock表示该函数是否为非阻塞，如果为1，该函数将在没有接收缓存可利用时立即返回，而如果为0，该函数在没有接收缓存可利用时睡眠。  
向用户空间进程发送的消息包含三个部份：netlink 消息头部、数据部份和控制字段，控制字段包含了内核发送netlink消息时，需要设置的目标地址与源地址，内核中消息是通过sk\_buff来管理的， linux/netlink.h中定义了NETLINK\_CB宏来方便消息的地址设置：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

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

例如：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

NETLINK\_CB(skb).pid = 0;  
NETLINK\_CB(skb).dst\_pid = 0;  
NETLINK\_CB(skb).dst\_group = 1;

字段pid表示消息发送者进程ID，也即源地址，对于内核，它为 0， dst\_pid 表示消息接收者进程 ID，也即目标地址，如果目标为组或内核，它设置为 0，否则 dst\_group 表示目标组地址，如果它目标为某一进程或内核，dst\_group 应当设置为 0。

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

static int send\_to\_user(struct packet\_info \*info)  
\{  
int ret;  
int size;  
unsigned char \*old\_tail;  
struct sk\_buff \*skb;  
struct nlmsghdr \*nlh;  
struct packet\_info \*packet;  
  
/\*计算消息总长：消息首部加上数据加度\*/  
size = NLMSG\_SPACE(sizeof(\*info));  
  
/\*分配一个新的套接字缓存\*/  
skb = alloc\_skb(size, GFP\_ATOMIC);  
old\_tail = skb->tail;  
  
/\*初始化一个netlink消息首部\*/  
nlh = NLMSG\_PUT(skb, 0, 0, IMP2\_K\_MSG, size-sizeof(\*nlh));  
/\*跳过消息首部，指向数据区\*/  
packet = NLMSG\_DATA(nlh);  
/\*初始化数据区\*/  
memset(packet, 0, sizeof(struct packet\_info));  
/\*填充待发送的数据\*/  
packet->src = info->src;  
packet->dest = info->dest;  
  
/\*计算skb两次长度之差，即netlink的长度总和\*/  
nlh->nlmsg\_len = skb->tail - old\_tail;  
/\*设置控制字段\*/  
NETLINK\_CB(skb).dst\_groups = 0;  
  
/\*发送数据\*/  
read\_lock\_bh(&user\_proc.lock);  
ret = netlink\_unicast(nlfd, skb, user\_proc.pid, MSG\_DONTWAIT);  
read\_unlock\_bh(&user\_proc.lock);  
  
  
\}

函数初始化netlink 消息首部，填充数据区，然后设置控制字段，这三部份都包含在skb\_buff中，最后调用netlink\_unicast函数把数据发送出去。  
函数中调用了netlink的一个重要的宏NLMSG\_PUT，它用于初始化netlink 消息首部：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

\#define NLMSG\_PUT(skb, pid, seq, type, len) /  
(\{ if (skb\_tailroom(skb) < (int)NLMSG\_SPACE(len)) goto nlmsg\_failure; /  
\_\_nlmsg\_put(skb, pid, seq, type, len); \})  
static \_\_inline\_\_ struct nlmsghdr \*  
\_\_nlmsg\_put(struct sk\_buff \*skb, u32 pid, u32 seq, int type, int len)  
\{  
struct nlmsghdr \*nlh;  
int size = NLMSG\_LENGTH(len);  
  
nlh = (struct nlmsghdr\*)skb\_put(skb, NLMSG\_ALIGN(size));  
nlh->nlmsg\_type = type;  
nlh->nlmsg\_len = size;  
nlh->nlmsg\_flags = 0;  
nlh->nlmsg\_pid = pid;  
nlh->nlmsg\_seq = seq;  
return nlh;  
\}

这个宏一个需要注意的地方是调用了nlmsg\_failure标签，所以在程序中应该定义这个标签。  
  
在内核中使用函数sock\_release来释放函数netlink\_kernel\_create()创建的netlink socket：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

void sock\_release(struct socket \* sock);

程序在退出模块中释放netlink sockets和netfilter hook：

[\[Copy to clipboard\]][Copy to clipboard] [\[ \- \]][Copy to clipboard]

CODE:

static void \_\_exit fini(void)  
\{  
if(nlfd)  
\{  
sock\_release(nlfd->socket); /\*释放netlink socket\*/  
\}  
nf\_unregister\_hook(&imp2\_ops); /\*撤锁netfilter 钩子\*/  
\}

[image003.gif]: /images/20220823/8f019a9d3ca546c1afde5661bf1db455.png
[image004.gif]: /images/20220823/40cfc902f65a4928966082deb75475d0.png
[Copy to clipboard]: http://linux.chinaunix.net/bbs/viewthread.php?tid=822500###