内核态与用户态通信方式

Linux下内核空间与用户空间进行通信的方式主要有system call、sysctl、procfs、模块参数、debugfs、relayfs、sysfs和netlink等。

Why NetlinK full-duplex

模块参数、sysfs、procfs、debugfs和relayfs都是基于文件系统，用于内核向用户发送消息；sysctl和system call是用户向内核发送消息。它们都是单工通信方式。netlink是一种特殊的通信方式，用于在内核空间和用户空间传递消息，是一种双工通信方式。使用地址协议簇AF_NETLINK，使用头文件include/linux/netlink.h。

simple to add

为新特性添加system call、sysctl或者procfs是一件复杂的工作，它们会污染kernel，破坏系统的稳定性，这是非常危险的。Netlink的添加，对内核的影响仅在于向netlink.h中添加一个固定的协议类型，然后内核模块和应用层的通信使用一套标准的API。 Netlink Socket APIs 用户空间 创建

int socket(int doamin, int type, int protocal);

domain填AF_NETLINK，type为SOCK_RAW或者SOCK_DGRAM。protocal可选NETLINK_ROUTE、NETLINK_FIREWALL、NETLINK_ARPD、NETLINK_ROUTE6和NETLINK_IP6_FW，或者传入自定义协议类型。

绑定

int bind(int fd, (struct sockaddr *)&nladdr, sizeof(nladdr));

netlink地址结构如下

struct sockaddr_nl{ sa_family_t nl_family; //AF_NETLINK unsigned short nl_pad; //0 __u32 nl_pid; //进程pid __u32 nl_groups; //多播组掩码}

如果进程仅仅使用一个netlink，nl_pid可以传入该进程的pid，

my_pid = getpid()；

如果一个进程的多个线程需要不同的netlink，使用如下方法获得nl_pid：

pthread_self << 16 | gitpid();

发送

int sendmsg(fd, &msg, 0);

struct nlmsghdr msg为netlink发送消息结构，

struct msghdr{ void *msg_name; //socket name int msg_namelen; //len of name struct iovec *msg_iov; //data block __kernel_size_t msg_iovlen; //num of block void *msg_control; //per protocol magic __kernel_size_t msg_controllen; //len of cmsg list unsigned msg_flags; }

其中需要填充的是msg_iov和msg_oivlen。

msg与其他结构体的关系如图所示

nlmsghdr结构体为消息头信息

struct nlmsghdr{ __u32 nlmsg_len; //len of msg __u16 nlmsg_type; //msg type __u16 nlmsg_flags; //additional flags __u32 nlmsg_seq; //sequence num __u32 nlmsg_pid; //send process pid}

nlmsg_len是整个消息的长度，包含头；

nlmsg_type对内核不透明；

nlmsg_flag被用于对消息的附加控制；

nlmsg_seq和nlmsg_pid被用于跟踪消息，对内核不透明。

要将地址结构体传入消息头部：

struct msghdr msg;msg.msg_name = (void *)&nladdr;msg.msg_namelen = sizeof(nladdr);

发送地址同样使用sockaddr_nl结构体，如果目的是内核，nl_pid和nl_groups都为0；如果消息为单播，目的为另一个进程，nl_pid是目的进程pid，nl_groups为0；如果消息为多播，目的是一个或多个多播组，nl_groups域中需填写所有目的多播组的掩码和。

结构体iovce结构如下

struct iovec iov;iov.iov_base = (void *)nlh;iov.iov_len = nlh->nlmsg_len;msg.msg_iov = &iov;msg.msg_iovlen = 1;

接收

接收时需要创建足够的buf，

struct sockadddr_nl nladdr;struct msghdr msg;struct iovec iov; iov.iov_base = (void *)nlh;iov.iov_len = MAX_NL_MSG_LEN;msg.msg_name = (void *)&nladdr;msg.msg_namelen = sizeof(nladdr); msg.msg_iov = &iov;msg.msg_iovlen = 1;recvmsg(fd, &msg, 0);

内核空间

内核空间的API由net/core/af_netlink.c支持。

可以在netlink.h中添加自定义协议类型：

#define NETLINK_TEST 17

创建

struct sock *netlink_kernel_create(int unit,  void (*input)(struct sock *sk, int len));

unit是netlink.h中定义的协议类型，*input是一个回调函数指针，接收到消息会触发这个函数。

发送

发送消息使用struct sk_buff *skb。

用以下方式设置本地地址：

NETLINK_CB(skb).groups = local_groups;NETLINK_CB(skb).pid = 0;

因为是在内核，pid = 0

用以下方式设置目的地址：

NETLINK_CB(skb).dst_groups = dst_groups;NETLINK_CB(skb).dst_pid = dst_pid;

发送单播函数为

int netlink_unicast(struct sock *sk, struct sk_buff *skb, u32 pid, int nonblock);

*sk为netlink_kernel_create()返回的结构体指针；

skb->data指向消息；

pid为应用程序的pid；

block表明如果当接收缓冲非法时数据分块还是返回错误值。

发送多播函数为

void netlink_broadcast(struct sock *sk, struct sk_buff *skb, u32 pid, u32 group, int allocation);

group是所有需要接收多播消息的组掩码和；

allocation是内核内存分配标志，中断上下文中使用GFP_ATOMIC，其他情况使用GFP_KERNEL。

销毁

sock_release(nl_sk->socket);

example user-space 初始化

#define MAX_NLMSG_PAYLOAD_LEN 128#define NETLINK_GROUP_MASK(group) (1 << group) int usr_netlink_init(int netlink_type, int *fd, int group){ struct nlmsghdr *nlh = NULL; struct sockaddr_nl addr;  memset((void *)&addr, 0x0, sizeof(addr));  if ((*fd = socket(PF_NETLINK, SOCK_RAW, netlink_type)) < 0) { /* error process*/ return -1; }  addr.nl_family = AF_NETLINK; addr.nl_pid = getpid(); addr.nl_groups = NETLINK_GROUP_MASK(group);  if (bind(*fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { /* error process */ close(*fd); *fd = -1; return -2; }  /* send pid to kernel */ if (us_netlink_send(*fd, 0, NULL, 0) < 0) { /* error process */ close(*fd); *fd = -1; return -3; }  return 0;}

发送

int usr_netlink_send(int fd, uint16 msg_type, char *data, int data_len){ struct nlmsghdr *nlh; struct msghdr msg; struct iovec iov; int msg_len;  if (data && (msg_len > MAX_NLMSG_PAYLOAD_LEN)) { return -1; }  memset((void*)&iov, 0x0, sizeof(iov)); memset((void*)&msg, 0x0, sizeof(msg));  msg_len = NLMSG_SPACE(data_len);  nlh = (struct nlmsghdr *)malloc(msg_len); if (NULL = nlh) { return -2; }  /* fill nlmsghdr */ memset(nlh, 0x0, msg_len); nlh->nlmsg_len = msg_len; nlh->nlmsg_pid = getpid(); nlh->nlmsg_type = msg_type; nlh->nlmsg_flags = 0;  if (data) { memcpy(NLMSG_DATA(nlh), data, msg_len); }  /* fill iovec */ iov.iov_base = (void *)nlh; iov.iov_len = nlh->nlmsg_len; msg.msg_iov = &iov; msg.msg_iovlen = 1;  if (sendmsg(fd, &msg, 0) < 0) { /* error process */ free(nlh); return -3; }  free(nlh); return 0;}

接收

int usr_netlink_recv(int fd, char *buf, int len){ struct iovec iov = {buf, len}; struct sockaddr_nl nl_src_addr; struct msghdr msg; int recv_len;  memset(&msg, 0x0, sizeof(struct msghdr)); memset(&nl_src_addr, 0x0, sizeof(struct sockaddr_nl));  msg.msg_name = (void *)&nl_src_addr; msg.msg_namelen = sizeof(nl_src_addr); msg.msg_iov = &iov; msg.msg_iovlen = 1;  recv_len = recvmsg(fd, &msg, 0); if (recv_len < 0) { /* recv error */ } else if (recv_len == 0) { /* recv EOF */ }  return recv_len;}

kernel 初始化

static struct sock *sg_knl_xxx_sk = NULL;static int sg_knl_xxx_pid = -1; void knl_netlink_init(){  struct net init_net;  sg_knl_xxx_sk = netlink_kernel_create(&init_net, NETLINK_TEST, 0, knl_neklink_recv, NULL, THIS_MODULE);}

接收

void knl_netlink_recv(struct sock *skb){ struct nlmsghdr *nlh = nlmsg_hdr(skb); sg_knl_xxx_pid = nlh->nlmsg_pid;}

发送

int group_mask(int group){ return (1 << group);} void knl_netlink_send(int msg_type, char *data, int data_len, int group){ struct sk_buff *skb = NULL; struct nlmsghdr *nlh = NULL; unsigned int msg_len = NLMSG_SPACE(data_len);  if(data && (data_len > MAX_PAYLOAD_LEN)) { /* error process */ return; }   skb = alloc_skb(msg_len, GFP_KERNEL); if (!skb) { /* erro process */ return; }  memset((void *)skb, 0x0, msg_len); nlh = nlmsg_put(skb, 0, 0, msg_type, msg_len, 0);  if(data) { memcpy(NLMSG_DATA(nlh), data, data_len); }   NETLINK_CB(skb).pid = 0; /*from kernel */ NETLINK_CB(skb).dst_group = group_mask(group);   /* if unicast */ netlink_unicast(sg_knl_xxx_sk, skb, sg_knl_xxx_pid, MSG_DONTWAIT); /* if mulicast */ //nlmsg_multicast(sg_knl_xxx_sk, skb, 0, group_mask(group), 0);}