linux 內核與用戶空間通信之netlink使用方法

Linux中的進程間通信機制源自於Unix平臺上的進程通信機制。Unix的兩大分支AT&T Unix和BSD Unix在進程通信實現機制上的各有所不同，前者形成了運行在單個計算機上的System V IPC，後者則實現了基於socket的進程間通信機制。同時Linux也遵循IEEE制定的Posix IPC標準，在三者的基礎之上實現了以下幾種主要的IPC機制：管道(Pipe)及命名管道(Named Pipe)，信號(Signal)，消息隊列(Message queue)，共享內存(Shared Memory)，信號量(Semaphore)，套接字(Socket)。通過這些IPC機制，用戶空間進程之間可以完成互相通信。爲了完成內核空間與用戶空間通信，Linux提供了基於socket的Netlink通信機制，可以實現內核與用戶空間數據的及時交換。

本文第2節概述相關研究工作，第3節與其他IPC機制對比，詳細介紹Netlink機制及其關鍵技術，第4節使用KGDB+GDB組合調試，通過一個示例程序演示Netlink通信過程。第5節做總結並指出Netlink通信機制的不足之處。

2 相關研究

到目前Linux提供了9種機制完成內核與用戶空間的數據交換，分別是內核啓動參數、模塊參數與 sysfs、sysctl、系統調用、netlink、procfs、seq_file、debugfs和relayfs，其中模塊參數與sysfs、procfs、debugfs、relayfs是基於文件系統的通信機制，用於內核空間向用戶控件輸出信息；sysctl、系統調用是由用戶空間發起的通信機制。由此可見，以上均爲單工通信機制，在內核空間與用戶空間的雙向互動數據交換上略顯不足。Netlink是基於socket的通信機制，由於socket本身的雙共性、突發性、不阻塞特點，因此能夠很好的滿足內核與用戶空間小量數據的及時交互，因此在Linux 2.6內核中廣泛使用，例如SELinux，Linux系統的防火牆分爲內核態的netfilter和用戶態的iptables，netfilter與iptables的數據交換就是通過Netlink機制完成。

3 Netlink機制及其關鍵技術

3.1 Netlink機制

Linux操作系統中當CPU處於內核狀態時，可以分爲有用戶上下文的狀態和執行硬件、軟件中斷兩種。其中當處於有用戶上下文時，由於內核態和用戶態的內存映射機制不同，不可直接將本地變量傳給用戶態的內存區；處於硬件、軟件中斷時，無法直接向用戶內存區傳遞數據，代碼執行不可中斷。針對傳統的進程間通信機制，他們均無法直接在內核態和用戶態之間使用，原因如下表：

通信方法	無法介於內核態與用戶態的原因
管道（不包括命名管道）	侷限於父子進程間的通信。
消息隊列	在硬、軟中斷中無法無阻塞地接收數據。
信號量	無法介於內核態和用戶態使用。
內存共享	需要信號量輔助，而信號量又無法使用。
套接字	在硬、軟中斷中無法無阻塞地接收數據。

1*（引自參考文獻5）

解決內核態和用戶態通信機制可分爲兩類：

處於有用戶上下文時，可以使用Linux提供的copy_from_user()和copy_to_user()函數完成，但由於這兩個函數可能阻塞，因此不能在硬件、軟件的中斷過程中使用。
處於硬、軟件中斷時。

2.1 可以通過Linux內核提供的spinlock自旋鎖實現內核線程與中斷過程的同步，由於內核線程運行在有上下文的進程中，因此可以在內核線程中使用套接字或消息隊列來取得用戶空間的數據，然後再將數據通過臨界區傳遞給中斷過程.

2.2 通過Netlink機制實現。Netlink 套接字的通信依據是一個對應於進程的標識，一般定爲該進程的 ID。Netlink通信最大的特點是對對中斷過程的支持，它在內核空間接收用戶空間數據時不再需要用戶自行啓動一個內核線程，而是通過另一個軟中斷調用用戶事先指定的接收函數。通過軟中斷而不是自行啓動內核線程保證了數據傳輸的及時性。

3.2 Netlink優點

Netlink相對於其他的通信機制具有以下優點：

使用Netlink通過自定義一種新的協議並加入協議族即可通過socket API使用Netlink協議完成數據交換，而ioctl和proc文件系統均需要通過程序加入相應的設備或文件。
Netlink使用socket緩存隊列，是一種異步通信機制，而ioctl是同步通信機制，如果傳輸的數據量較大，會影響系統性能。
Netlink支持多播，屬於一個Netlink組的模塊和進程都能獲得該多播消息。
Netlink允許內核發起會話，而ioctl和系統調用只能由用戶空間進程發起。

在內核源碼有關Netlink協議的頭文件中包含了內核預定義的協議類型，如下所示：

[cpp] view plain copy print?

#define NETLINK_ROUTE 0
#define NETLINK_W1 1
#define NETLINK_USERSOCK 2
#define NETLINK_FIREWALL 3
#define NETLINK_INET_DIAG 4
#define NETLINK_NFLOG 5
#define NETLINK_XFRM 6
#define NETLINK_SELINUX 7
#define NETLINK_ISCSI 8
#define NETLINK_AUDIT 9
#define NETLINK_FIB_LOOKUP 10
#define NETLINK_CONNECTOR 11
#define NETLINK_NETFILTER 12
#define NETLINK_IP6_FW 13
#define NETLINK_DNRTMSG 14
#define NETLINK_KOBJECT_UEVENT 15
#define NETLINK_GENERIC 16

#define NETLINK_ROUTE         0   

#define NETLINK_W1             1    

#define NETLINK_USERSOCK     2    

#define NETLINK_FIREWALL      3     

#define NETLINK_INET_DIAG     4       

#define NETLINK_NFLOG         5      

#define NETLINK_XFRM          6      

#define NETLINK_SELINUX       7      

#define NETLINK_ISCSI           8      

#define NETLINK_AUDIT          9      

#define NETLINK_FIB_LOOKUP    10

#define NETLINK_CONNECTOR    11

#define NETLINK_NETFILTER      12     

#define NETLINK_IP6_FW          13

#define NETLINK_DNRTMSG       14     

#define NETLINK_KOBJECT_UEVENT 15     

#define NETLINK_GENERIC        16

上述這些協議已經爲不同的系統應用所使用，每種不同的應用都有特有的傳輸數據的格式，因此如果用戶不使用這些協議，需要加入自己定義的協議號。對於每一個Netlink協議類型，可以有多達 32多播組，每一個多播組用一個位表示，Netlink 的多播特性使得發送消息給同一個組僅需要一次系統調用，因而對於需要多撥消息的應用而言，大大地降低了系統調用的次數。

建立Netlink會話過程如下：

內核使用與標準socket API類似的一套API完成通信過程。首先通過netlink_kernel_create()創建套接字，該函數的原型如下：

[cpp] view plain copy print?

struct sock *netlink_kernel_create(struct net *net,
int unit,unsigned int groups,
void (*input)(struct sk_buff *skb),
struct mutex *cb_mutex,
struct module *module);

struct sock *netlink_kernel_create(struct net *net,

                  int unit,unsigned int groups,

                  void (*input)(struct sk_buff *skb),

                  struct mutex *cb_mutex,

                  struct module *module);

其中net參數是網絡設備命名空間指針，input函數是netlink socket在接受到消息時調用的回調函數指針，module默認爲THIS_MODULE.

然後用戶空間進程使用標準Socket API來創建套接字，將進程ID發送至內核空間，用戶空間創建使用socket()創建套接字，該函數的原型如下：

int socket(int domain, int type, int protocol);

其中domain值爲PF_NETLINK，即Netlink使用協議族。protocol爲Netlink提供的協議或者是用戶自定義的協議，Netlink提供的協議包括NETLINK_ROUTE, NETLINK_FIREWALL, NETLINK_ARPD, NETLINK_ROUTE6和 NETLINK_IP6_FW。

接着使用bind函數綁定。Netlink的bind()函數把一個本地socket地址(源socket地址)與一個打開的socket進行關聯。完成綁定，內核空間接收到用戶進程ID之後便可以進行通訊。

用戶空間進程發送數據使用標準socket API中sendmsg()函數完成，使用時需添加struct msghdr消息和nlmsghdr消息頭。一個netlink消息體由nlmsghdr和消息的payload部分組成，輸入消息後，內核會進入nlmsghdr指向的緩衝區。

內核空間發送數據使用獨立創建的sk_buff緩衝區，Linux定義瞭如下宏方便對於緩衝區地址的設置，如下所示：

#define NETLINK_CB(skb) (*(struct netlink_skb_parms*)&((skb)->cb))

在對緩衝區設置完成消息地址之後，可以使用netlink_unicast()來發布單播消息，netlink_unicast()原型如下：

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

參數sk爲函數netlink_kernel_create()返回的socket，參數skb存放消息，它的data字段指向要發送的netlink消息結構，而skb的控制塊保存了消息的地址信息，前面的宏NETLINK_CB(skb)就用於方便設置該控制塊，參數pid爲接收消息進程的pid，參數nonblock表示該函數是否爲非阻塞，如果爲1，該函數將在沒有接收緩存可利用時立即返回，而如果爲0，該函數在沒有接收緩存可利用時睡眠。

內核模塊或子系統也可以使用函數netlink_broadcast來發送廣播消息：

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

前面的三個參數與netlink_unicast相同，參數group爲接收消息的多播組，該參數的每一個代表一個多播組，因此如果發送給多個多播組，就把該參數設置爲多個多播組組ID的位或。參數allocation爲內核內存分配類型，一般地爲GFP_ATOMIC或GFP_KERNEL，GFP_ATOMIC用於原子的上下文（即不可以睡眠），而GFP_KERNEL用於非原子上下文。

接收數據時程序需要申請足夠大的空間來存儲netlink消息頭和消息的payload部分。然後使用標準函數接口recvmsg()來接收netlink消息

4 Netlink通信過程

調試平臺：Vmware 5.5 + Fedora Core 10(兩臺，一臺作爲host機，一臺作爲target機)。

調試程序：分爲內核模塊和用戶空間程序兩部分，當內核模塊被加載後，運行用戶空間程序，由用戶空間發起Netlink會話，和內核模塊進行數據交換。

被加載的內核模塊無法通過外加的調試器進行調試，KGDB提供了一種內核源碼級別的調試機制。Linux內核自2.6.26版本之後在內核中內置了KGDB選項，編譯內核時需要選擇與之相關的選項，調試時host端需使用帶有符號表的vmlinz內核，target端使用gdb調試用戶空間的程序。

用戶空間程序關鍵代碼如下：

[cpp] view plain copy print?

int send_pck_to_kern(u8 op, const u8 *data, u16 data_len)
{
struct user_data_ *pck;
int ret;
pck = (struct user_data_*)calloc(1, sizeof(*pck) + data_len);
if(!pck) {
printf("calloc in %s failed!!!\n", __FUNCTION__);
return -1;
}
pck->magic_num = MAGIC_NUM_RNQ;
pck->op = op;
pck->data_len = data_len;
memcpy(pck->data, data, data_len);
ret = send_to_kern((const u8*)pck, sizeof(*pck) + data_len);
if(ret)
printf("send_to_kern in %s failed!!!\n", __FUNCTION__);
free(pck);
return ret ? -1 : 0;
}
static void recv_from_nl()
{
char buf[1000];
int len;
struct iovec iov = {buf, sizeof(buf)};
struct sockaddr_nl sa;
struct msghdr msg;
struct nlmsghdr *nh;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&sa;
msg.msg_namelen = sizeof(sa);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
//len = recvmsg(nl_sock, &msg, 0);
len = recvmsg(nl_sock, &msg, 0);
for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);
nh = NLMSG_NEXT (nh, len)) {
// The end of multipart message.
if (nh->nlmsg_type == NLMSG_DONE) {
puts("nh->nlmsg_type == NLMSG_DONE");
return;
}
if (nh->nlmsg_type == NLMSG_ERROR) {
// Do some error handling.
puts("nh->nlmsg_type == NLMSG_ERROR");
return;
}
#if 1
puts("Data received from kernel:");
hex_dump((u8*)NLMSG_DATA(nh), NLMSG_PAYLOAD(nh, 0));
#endif
}
}

int send_pck_to_kern(u8 op, const u8 *data, u16 data_len)

{

    struct user_data_ *pck;

    int ret;

 

    pck = (struct user_data_*)calloc(1, sizeof(*pck) + data_len);

    if(!pck) {

       printf("calloc in %s failed!!!\n", __FUNCTION__);

       return -1;

    }

 

    pck->magic_num = MAGIC_NUM_RNQ;

    pck->op = op;

    pck->data_len = data_len;

    memcpy(pck->data, data, data_len);

 

    ret = send_to_kern((const u8*)pck, sizeof(*pck) + data_len);

    if(ret)

       printf("send_to_kern in %s failed!!!\n", __FUNCTION__);

   

    free(pck);

 

    return ret ? -1 : 0;

}

 

static void recv_from_nl()

{

    char buf[1000];

    int len;

    struct iovec iov = {buf, sizeof(buf)};

    struct sockaddr_nl sa;

    struct msghdr msg;

    struct nlmsghdr *nh;

 

    memset(&msg, 0, sizeof(msg));

    msg.msg_name = (void *)&sa;

    msg.msg_namelen = sizeof(sa);

    msg.msg_iov = &iov;

    msg.msg_iovlen = 1;

 

    //len = recvmsg(nl_sock, &msg, 0);

    len = recvmsg(nl_sock, &msg, 0);

 

    for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len);

           nh = NLMSG_NEXT (nh, len)) {

       // The end of multipart message.

       if (nh->nlmsg_type == NLMSG_DONE) {

           puts("nh->nlmsg_type == NLMSG_DONE");

           return;

       }

 

       if (nh->nlmsg_type == NLMSG_ERROR) {

           // Do some error handling.

           puts("nh->nlmsg_type == NLMSG_ERROR");

           return;

       }

 

 

#if 1

       puts("Data received from kernel:");

       hex_dump((u8*)NLMSG_DATA(nh), NLMSG_PAYLOAD(nh, 0));

#endif

    }

}

內核模塊需要防止資源搶佔，保證Netlink資源互斥佔有，內核模塊部分關鍵代碼如下：

[cpp] view plain copy print?

static void nl_rcv(struct sk_buff *skb)
{
mutex_lock(&nl_mtx);
netlink_rcv_skb(skb, &nl_rcv_msg);
mutex_unlock(&nl_mtx);
}
static int nl_send_msg(const u8 *data, int data_len)
{
struct nlmsghdr *rep;
u8 *res;
struct sk_buff *skb;
if(g_pid < 0 || g_nl_sk == NULL) {
printk("Invalid parameter, g_pid = %d, g_nl_sk = %p\n",
g_pid, g_nl_sk);
return -1;
}
skb = nlmsg_new(data_len, GFP_KERNEL);
if(!skb) {
printk("nlmsg_new failed!!!\n");
return -1;
}
if(g_debug_level > 0) {
printk("Data to be send to user space:\n");
hex_dump((void*)data, data_len);
}
rep = __nlmsg_put(skb, g_pid, 0, NLMSG_NOOP, data_len, 0);
res = nlmsg_data(rep);
memcpy(res, data, data_len);
netlink_unicast(g_nl_sk, skb, g_pid, MSG_DONTWAIT);
return 0;
}
static int nl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
const u8 res_data[] = "Hello, user";
size_t data_len;
u8 *buf;
struct user_data_ *pck;
struct user_req *req, *match = NULL;
g_pid = NETLINK_CB(skb).pid;
buf = (u8*)NLMSG_DATA(nlh);
data_len = nlmsg_len(nlh);
if(data_len < sizeof(struct user_data_)) {
printk("Too short data from user space!!!\n");
return -1;
}
pck = (struct user_data_ *)buf;
if(pck->magic_num != MAGIC_NUM_RNQ) {
printk("Magic number not matched!!!\n");
return -1;
}
if(g_debug_level > 0) {
printk("Data from user space:\n");
hex_dump(buf, data_len);
}
req = user_reqs;
while(req->op) {
if(req->op == pck->op) {
match = req;
break;
}
req++;
}
if(match) {
match->handler(buf, data_len);
}
nl_send_msg(res_data, sizeof(res_data));
return 0;
}

static void nl_rcv(struct sk_buff *skb)

{

    mutex_lock(&nl_mtx);

 

    netlink_rcv_skb(skb, &nl_rcv_msg);

 

    mutex_unlock(&nl_mtx);

}

 

 

static int nl_send_msg(const u8 *data, int data_len)

{

    struct nlmsghdr *rep;

    u8 *res;

    struct sk_buff *skb;

 

    if(g_pid < 0 || g_nl_sk == NULL) {

       printk("Invalid parameter, g_pid = %d, g_nl_sk = %p\n",

                     g_pid, g_nl_sk);

       return -1;

    }

 

    skb = nlmsg_new(data_len, GFP_KERNEL);

    if(!skb) {

       printk("nlmsg_new failed!!!\n");

       return -1;

    }

 

    if(g_debug_level > 0) {

       printk("Data to be send to user space:\n");

       hex_dump((void*)data, data_len);

    }

 

    rep = __nlmsg_put(skb, g_pid, 0, NLMSG_NOOP, data_len, 0);

    res = nlmsg_data(rep);

    memcpy(res, data, data_len);

    netlink_unicast(g_nl_sk, skb, g_pid, MSG_DONTWAIT);

 

    return 0;

}

 

static int nl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)

{

    const u8 res_data[] = "Hello, user";

    size_t data_len;

   

    u8 *buf;

    struct user_data_ *pck;

    struct user_req *req, *match = NULL;

   

   

    g_pid = NETLINK_CB(skb).pid;

 

    buf = (u8*)NLMSG_DATA(nlh);

    data_len = nlmsg_len(nlh);

 

    if(data_len < sizeof(struct user_data_)) {

       printk("Too short data from user space!!!\n");

       return -1;

    }

 

    pck = (struct user_data_ *)buf;

    if(pck->magic_num != MAGIC_NUM_RNQ) {

       printk("Magic number not matched!!!\n");

       return -1;

    }

 

    if(g_debug_level > 0) {

       printk("Data from user space:\n");

       hex_dump(buf, data_len);

    }

 

 

    req = user_reqs;

    while(req->op) {

       if(req->op == pck->op) {

           match = req;

           break;

       }

 

       req++;

    }

 

    if(match) {

       match->handler(buf, data_len);

    }

 

 

    nl_send_msg(res_data, sizeof(res_data));

 

    return 0;

}

5.其他相關說明

Netlink 是一種特殊的 socket，它是 Linux 所特有的，類似於 BSD 中的AF_ROUTE 但又遠比它的功能強大，目前在最新的 Linux 內核（2.6.14）中使用netlink 進行應用與內核通信的應用很多，包括：路由 daemon（NETLINK_ROUTE），1-wire 子系統（NETLINK_W1），用戶態 socket 協議（NETLINK_USERSOCK），防火牆（NETLINK_FIREWALL），socket 監視（NETLINK_INET_DIAG），netfilter 日誌（NETLINK_NFLOG），ipsec 安全策略（NETLINK_XFRM），SELinux 事件通知（NETLINK_SELINUX），iSCSI 子系統（NETLINK_ISCSI），進程審計（NETLINK_AUDIT），轉發信息表查詢（NETLINK_FIB_LOOKUP），netlink connector(NETLINK_CONNECTOR),netfilter 子系統（NETLINK_NETFILTER），IPv6 防火牆（NETLINK_IP6_FW），DECnet 路由信息（NETLINK_DNRTMSG），內核事件向用戶態通知（NETLINK_KOBJECT_UEVENT），通用 netlink（NETLINK_GENERIC）。

Netlink 是一種在內核與用戶應用間進行雙向數據傳輸的非常好的方式，用戶態應用使用標準的 socket API 就可以使用 netlink 提供的強大功能，內核態需要使用專門的內核 API 來使用 netlink。

Netlink 相對於系統調用，ioctl 以及 /proc 文件系統而言具有以下優點：

1，爲了使用 netlink，用戶僅需要在 include/linux/netlink.h 中增加一個新類型的 netlink 協議定義即可，如 #define NETLINK_MYTEST 17 然後，內核和用戶態應用就可以立即通過 socket API 使用該 netlink 協議類型進行數據交換。但系統調用需要增加新的系統調用，ioctl 則需要增加設備或文件，那需要不少代碼，proc 文件系統則需要在 /proc 下添加新的文件或目錄，那將使本來就混亂的 /proc 更加混亂。

2. netlink是一種異步通信機制，在內核與用戶態應用之間傳遞的消息保存在socket緩存隊列中，發送消息只是把消息保存在接收者的socket的接收隊列，而不需要等待接收者收到消息，但系統調用與 ioctl 則是同步通信機制，如果傳遞的數據太長，將影響調度粒度。

3．使用 netlink 的內核部分可以採用模塊的方式實現，使用 netlink 的應用部分和內核部分沒有編譯時依賴，但系統調用就有依賴，而且新的系統調用的實現必須靜態地連接到內核中，它無法在模塊中實現，使用新系統調用的應用在編譯時需要依賴內核。

4．netlink 支持多播，內核模塊或應用可以把消息多播給一個netlink組，屬於該neilink 組的任何內核模塊或應用都能接收到該消息，內核事件向用戶態的通知機制就使用了這一特性，任何對內核事件感興趣的應用都能收到該子系統發送的內核事件，在後面的文章中將介紹這一機制的使用。

5．內核可以使用 netlink 首先發起會話，但系統調用和 ioctl 只能由用戶應用發起調用。

6．netlink 使用標準的 socket API，因此很容易使用，但系統調用和 ioctl則需要專門的培訓才能使用。

用戶態使用 netlink

用戶態應用使用標準的socket APIs， socket(), bind(), sendmsg(), recvmsg() 和 close() 就能很容易地使用 netlink socket，查詢手冊頁可以瞭解這些函數的使用細節，本文只是講解使用 netlink 的用戶應該如何使用這些函數。注意，使用 netlink 的應用必須包含頭文件 linux/netlink.h。當然 socket 需要的頭文件也必不可少，sys/socket.h。

爲了創建一個 netlink socket，用戶需要使用如下參數調用 socket():

 socket(AF_NETLINK, SOCK_RAW, netlink_type)

第一個參數必須是 AF_NETLINK 或 PF_NETLINK，在 Linux 中，它們倆實際爲一個東西，它表示要使用netlink，第二個參數必須是SOCK_RAW或SOCK_DGRAM，第三個參數指定netlink協議類型，如前面講的用戶自定義協議類型NETLINK_MYTEST， NETLINK_GENERIC是一個通用的協議類型，它是專門爲用戶使用的，因此，用戶可以直接使用它，而不必再添加新的協議類型。內核預定義的協議類型有：

[cpp] view plain copy print?

#define NETLINK_ROUTE 0
#define NETLINK_W1 1
#define NETLINK_USERSOCK 2
#define NETLINK_FIREWALL 3
#define NETLINK_INET_DIAG 4
#define NETLINK_NFLOG 5
#define NETLINK_XFRM 6
#define NETLINK_SELINUX 7
#define NETLINK_ISCSI 8
#define NETLINK_AUDIT 9
#define NETLINK_FIB_LOOKUP 10
#define NETLINK_CONNECTOR 11
#define NETLINK_NETFILTER 12
#define NETLINK_IP6_FW 13
#define NETLINK_DNRTMSG 14
#define NETLINK_KOBJECT_UEVENT 15
#define NETLINK_GENERIC 16

#define NETLINK_ROUTE 0
#define NETLINK_W1 1
#define NETLINK_USERSOCK 2 
#define NETLINK_FIREWALL 3
#define NETLINK_INET_DIAG 4
#define NETLINK_NFLOG 5
#define NETLINK_XFRM 6 
#define NETLINK_SELINUX 7 
#define NETLINK_ISCSI 8 
#define NETLINK_AUDIT 9 
#define NETLINK_FIB_LOOKUP 10 
#define NETLINK_CONNECTOR 11 
#define NETLINK_NETFILTER 12 
#define NETLINK_IP6_FW 13 
#define NETLINK_DNRTMSG 14 
#define NETLINK_KOBJECT_UEVENT 15 
#define NETLINK_GENERIC 16

對於每一個netlink協議類型，可以有多達 32多播組，每一個多播組用一個位表示，netlink 的多播特性使得發送消息給同一個組僅需要一次系統調用，因而對於需要多撥消息的應用而言，大大地降低了系統調用的次數。

函數 bind() 用於把一個打開的 netlink socket 與 netlink 源 socket 地址綁定在一起。netlink socket 的地址結構如下：

[cpp] view plain copy print?

struct sockaddr_nl {
sa_family_t nl_family;
unsigned short nl_pad;
__u32 nl_pid;
__u32 nl_groups;
};

struct sockaddr_nl {
   sa_family_t nl_family;
   unsigned short nl_pad;
   __u32 nl_pid;
   __u32 nl_groups;
 };

字段 nl_family 必須設置爲 AF_NETLINK 或着 PF_NETLINK，字段 nl_pad 當前沒有使用，因此要總是設置爲 0，字段 nl_pid 爲接收或發送消息的進程的 ID，如果希望內核處理消息或多播消息，就把該字段設置爲 0，否則設置爲處理消息的進程 ID。字段 nl_groups 用於指定多播組，bind 函數用於把調用進程加入到該字段指定的多播組，如果設置爲 0，表示調用者不加入任何多播組。

傳遞給 bind 函數的地址的 nl_pid 字段應當設置爲本進程的進程 ID，這相當於 netlink socket 的本地地址。但是，對於一個進程的多個線程使用 netlink socket 的情況，字段 nl_pid 則可以設置爲其它的值，如：

pthread_self() << 16 | getpid();

因此字段 nl_pid 實際上未必是進程 ID,它只是用於區分不同的接收者或發送者的一個標識，用戶可以根據自己需要設置該字段。函數 bind 的調用方式如下：

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

fd爲前面的 socket 調用返回的文件描述符，參數 nladdr 爲 struct sockaddr_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 需如下設置：

[cpp] view plain copy print?

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

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

其中 nladdr 爲消息接收者的 netlink 地址。

struct nlmsghdr 爲 netlink socket 自己的消息頭，這用於多路複用和多路分解 netlink 定義的所有協議類型以及其它一些控制，netlink 的內核實現將利用這個消息頭來多路複用和多路分解已經其它的一些控制，因此它也被稱爲netlink 控制塊。因此，應用在發送 netlink 消息時必須提供該消息頭。

[cpp] view plain copy print?

struct nlmsghdr {
__u32 nlmsg_len;
__u16 nlmsg_type;
__u16 nlmsg_flags;
__u32 nlmsg_seq;
__u32 nlmsg_pid;
};

struct nlmsghdr {
    __u32 nlmsg_len; 
    __u16 nlmsg_type; 
    __u16 nlmsg_flags;
    __u32 nlmsg_seq;
    __u32 nlmsg_pid;
};

字段 nlmsg_len 指定消息的總長度，包括緊跟該結構的數據部分長度以及該結構的大小，字段 nlmsg_type 用於應用內部定義消息的類型，它對 netlink 內核實現是透明的，因此大部分情況下設置爲 0，字段 nlmsg_flags 用於設置消息標誌，可用的標誌包括：

[cpp] view plain copy print?

#define NLM_F_REQUEST 1
#define NLM_F_MULTI 2
#define NLM_F_ACK 4
#define NLM_F_ECHO 8
#define NLM_F_ROOT 0x100
#define NLM_F_MATCH 0x200
#define NLM_F_ATOMIC 0x400
#define NLM_F_DUMP (NLM_F_ROOT|NLM_F_MATCH)
#define NLM_F_REPLACE 0x100
#define NLM_F_EXCL 0x200
#define NLM_F_CREATE 0x400
#define NLM_F_APPEND 0x800

#define NLM_F_REQUEST 1 
#define NLM_F_MULTI     2 
#define NLM_F_ACK        4 
#define NLM_F_ECHO      8 
#define NLM_F_ROOT     0x100 
#define NLM_F_MATCH    0x200 
#define NLM_F_ATOMIC  0x400 
#define NLM_F_DUMP      (NLM_F_ROOT|NLM_F_MATCH) 
#define NLM_F_REPLACE  0x100 
#define NLM_F_EXCL       0x200 
#define NLM_F_CREATE   0x400 
#define NLM_F_APPEND   0x800

標誌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 需要它進行一些複雜的操作），字段 nlmsg_seq 和 nlmsg_pid 用於應用追蹤消息，前者表示順序號，後者爲消息來源進程 ID。下面是一個示例：

[cpp] view plain copy print?

#define MAX_MSGSIZE 1024
char buffer[] = "An example message";
struct nlmsghdr nlhdr;
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_MSGSIZE));
strcpy(NLMSG_DATA(nlhdr),buffer);
nlhdr->nlmsg_len = NLMSG_LENGTH(strlen(buffer));
nlhdr->nlmsg_pid = getpid();
nlhdr->nlmsg_flags = 0;

#define MAX_MSGSIZE 1024
char buffer[] = "An example message"; 
struct nlmsghdr nlhdr; 
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_MSGSIZE)); 
strcpy(NLMSG_DATA(nlhdr),buffer); 
nlhdr->nlmsg_len = NLMSG_LENGTH(strlen(buffer)); 
nlhdr->nlmsg_pid = getpid(); 
nlhdr->nlmsg_flags = 0;

結構 struct iovec 用於把多個消息通過一次系統調用來發送，下面是該結構使用示例：

[cpp] view plain copy print?

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

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

在完成以上步驟後，消息就可以通過下面語句直接發送：

sendmsg(fd, &msg, 0);

應用接收消息時需要首先分配一個足夠大的緩存來保存消息頭以及消息的數據部分，然後填充消息頭，添完後就可以直接調用函數 recvmsg() 來接收。

[cpp] view plain copy print?

#define MAX_NL_MSG_LEN 1024
struct sockaddr_nl nladdr;
struct msghdr msg;
struct iovec iov;
struct nlmsghdr * nlhdr;
nlhdr = (struct nlmsghdr *)malloc(MAX_NL_MSG_LEN);
iov.iov_base = (void *)nlhdr;
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);

#define MAX_NL_MSG_LEN 1024 
struct sockaddr_nl nladdr; 
struct msghdr msg; 
struct iovec iov; 
struct nlmsghdr * nlhdr; 
nlhdr = (struct nlmsghdr *)malloc(MAX_NL_MSG_LEN); 
iov.iov_base = (void *)nlhdr; 
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);

注意：fd爲socket調用打開的netlink socket描述符。

在消息接收後，nlhdr指向接收到的消息的消息頭，nladdr保存了接收到的消息的目標地址，宏NLMSG_DATA(nlhdr)返回指向消息的數據部分的指針。

在linux/netlink.h中定義了一些方便對消息進行處理的宏，這些宏包括：

#define NLMSG_ALIGNTO 4

#define NLMSG_ALIGN(len)    ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )

宏NLMSG_ALIGN(len)用於得到不小於len且字節對齊的最小數值。

#define NLMSG_LENGTH(len)   ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))

宏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(struct nlmsghdr) && \

(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的長度。

函數close用於關閉打開的netlink socket。

netlink內核API

netlink的內核實現在.c文件net/core/af_netlink.c中，內核模塊要想使用netlink，也必須包含頭文件linux/netlink.h。內核使用netlink需要專門的API，這完全不同於用戶態應用對netlink的使用。如果用戶需要增加新的netlink協議類型，必須通過修改linux/netlink.h來實現，當然，目前的netlink實現已經包含了一個通用的協議類型NETLINK_GENERIC以方便用戶使用，用戶可以直接使用它而不必增加新的協議類型。前面講到，爲了增加新的netlink協議類型，用戶僅需增加如下定義到linux/netlink.h就可以：

#define NETLINK_MYTEST 17

只要增加這個定義之後，用戶就可以在內核的任何地方引用該協議。

在內核中，爲了創建一個netlink socket用戶需要調用如下函數：

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

參數unit表示netlink協議類型，如NETLINK_MYTEST，參數input則爲內核模塊定義的netlink消息處理函數，當有消息到達這個netlink socket時，該input函數指針就會被引用。函數指針input的參數sk實際上就是函數netlink_kernel_create返回的struct sock指針，sock實際是socket的一個內核表示數據結構，用戶態應用創建的socket在內核中也會有一個struct sock結構來表示。下面是一個input函數的示例：

void input (struct sock *sk, int len) { struct sk_buff *skb; struct nlmsghdr *nlh = NULL; u8 *data = NULL; while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) { nlh = (struct nlmsghdr *)skb->data; data = NLMSG_DATA(nlh); } }

函數input()會在發送進程執行sendmsg()時被調用，這樣處理消息比較及時，但是，如果消息特別長時，這樣處理將增加系統調用sendmsg()的執行時間，對於這種情況，可以定義一個內核線程專門負責消息接收，而函數input的工作只是喚醒該內核線程，這樣sendmsg將很快返回。

函數skb = skb_dequeue(&sk->receive_queue)用於取得socket sk的接收隊列上的消息，返回爲一個struct sk_buff的結構，skb->data指向實際的netlink消息。

函數skb_recv_datagram(nl_sk)也用於在netlink socket nl_sk上接收消息，與skb_dequeue的不同指出是，如果socket的接收隊列上沒有消息，它將導致調用進程睡眠在等待隊列nl_sk->sk_sleep，因此它必須在進程上下文使用，剛纔講的內核線程就可以採用這種方式來接收消息。

下面的函數input就是這種使用的示例：

void input (struct sock *sk, int len) { wake_up_interruptible(sk->sk_sleep); }

當內核中發送netlink消息時，也需要設置目標地址與源地址，而且內核中消息是通過struct sk_buff來管理的， linux/netlink.h中定義了一個宏：

#define NETLINK_CB(skb) (*(struct netlink_skb_parms*)&((skb)->cb))

來方便消息的地址設置。下面是一個消息地址設置的例子：

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。

在內核中，模塊調用函數 netlink_unicast 來發送單播消息：

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

內核模塊或子系統也可以使用函數netlink_broadcast來發送廣播消息：

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

在內核中使用函數sock_release來釋放函數netlink_kernel_create()創建的netlink socket：

void sock_release(struct socket * sock);

注意函數netlink_kernel_create()返回的類型爲struct sock，因此函數sock_release應該這種調用：

sock_release(sk->sk_socket);

sk爲函數netlink_kernel_create()的返回值。

sk爲函數netlink_kernel_create()的返回值。在源代碼包中給出了一個使用 netlink 的示例，它包括一個內核模塊 netlink-exam-kern.c 和兩個應用程序 netlink-exam-user-recv.c, netlink-exam-user-send.c。內核模塊必須先插入到內核，然後在一個終端上運行用戶態接收程序，在另一個終端上運行用戶態發送程序，發送程序讀取參數指定的文本文件並把它作爲 netlink 消息的內容發送給內核模塊，內核模塊接受該消息保存到內核緩存中，它也通過proc接口出口到 procfs，因此用戶也能夠通過 /proc/netlink_exam_buffer 看到全部的內容，同時內核也把該消息發送給用戶態接收程序，用戶態接收程序將把接收到的內容輸出到屏幕上。

linux 內核與用戶空間通信之netlink使用方法

2 相關研究

3 Netlink機制及其關鍵技術

3.1 Netlink機制

3.2 Netlink優點

4 Netlink通信過程

SQL優化-20231016

Socket編程實踐(13) --UNIX域協議

C++筆試題總結（一）

Socket編程實踐(5) --TCP粘包問題與解決

數據結構基礎(1) --Swap & Bubble-Sort & Select-Sort

數據結構基礎(8) --單鏈表的設計與實現(1)之基本操作

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結