Netlink 内核实现分析（一）：创建

我就是我 2022-11-15 14:29 304阅读 0赞

Netlink 是一种IPC（Inter Process Commumicate）机制，它是一种用于内核与用户空间通信的机制，同时它也以用于进程间通信（Netlink 更多用于内核通信，进程之间通信更多使用Unix域套接字）。在一般情况下，用户态和内核态通信会使用传统的Ioctl、sysfs属性文件或者procfs属性文件，这3种通信方式都是同步通信方式，由用户态主动发起向内核态的通信，内核无法主动发起通信。而Netlink是一种异步全双工的通信方式，它支持由内核态主动发起通信，内核为Netlink通信提供了一组特殊的API接口，用户态则基于socket  API，内核发送的数据会保存在接收进程socket 的接收缓存中，由接收进程处理。Netlink 有以下优点：

1、双向全双工异步传输，支持由内核主动发起传输通信，而不需要用户空间出发(例如使用ioctl这类的单工方式)。如此用户空间在等待内核某种触发条件满足时就无需不断轮询，而异步接收内核消息即可。

2、支持组播传输，即内核态可以将消息发送给多个接收进程，这样就不用每个进程单独来查询了。

Netlink架构框图如下：

目前在Linux 4.1.x 的主线内核版本中，已经有许多内核模块使用netlink 机制，其中驱动模型中使用的uevent 就是基于netlink 实现。目前 netlink 协议族支持32种协议类型，它们定义在 include/uapi/linux/netlink.h 中：

\#define NETLINK\_ROUTE        0    /\* Routing/device hook                \*/  
\#define NETLINK\_UNUSED        1    /\* Unused number                \*/  
\#define NETLINK\_USERSOCK    2    /\* Reserved for user mode socket protocols     \*/  
\#define NETLINK\_FIREWALL    3    /\* Unused number, formerly ip\_queue        \*/  
\#define NETLINK\_SOCK\_DIAG    4    /\* 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  
/\* leave room for NETLINK\_DM (DM Events) \*/  
\#define NETLINK\_SCSITRANSPORT    18    /\* SCSI Transports \*/  
\#define NETLINK\_ECRYPTFS    19  
\#define NETLINK\_RDMA        20  
\#define NETLINK\_CRYPTO        21    /\* Crypto layer \*/  
   
\#define NETLINK\_INET\_DIAG    NETLINK\_SOCK\_DIAG  
   
\#define MAX\_LINKS 32</span>  
现在4.1.x 的内核版本中已经定义了22种协议类型，其中NETLINK\_ROUTE是用于设置和查询路由表等网络核心模块的，NETLINK\_KOBJECT\_UEVENT是用于uevent消息通信的......  
对于在实际的项目中，可能会有一些定制化的需求，以上这几种专用的协议类型无法满足，这时可以在不超过最大32种类型的基础之上自行添加。但是一般情况下这样做有些不妥，于是内核开发者就设计了一种通用netlink 协议类型（Generic Netlink）NETLINK\_GENERIC，它就是一个Netlink复用器，便于用户自行扩展子协议类型（后面我会使用该Generic Netlink 编写一个示例程序用于演示内核和用户空间的通信）。

下面以linux 4.1.12版本的内核源码为例来分析Netlink的具体创建和通信流程。

一、Netlink子系统初始化  
内核Netlink的初始化在系统启动阶段完成，初始化代码在af\_netlink.c的netlink\_proto\_init()函数中，整个初始化流程如下：  
   
图1 netlink子系统初始化  
static int \_\_init netlink\_proto\_init(void)  
\{  
    int i;  
    int err = proto\_register(&netlink\_proto, 0);  
   
    if (err != 0)  
        goto out;  
   
    BUILD\_BUG\_ON(sizeof(struct netlink\_skb\_parms) > FIELD\_SIZEOF(struct sk\_buff, cb));  
   
    nl\_table = kcalloc(MAX\_LINKS, sizeof(\*nl\_table), GFP\_KERNEL);  
    if (!nl\_table)  
        goto panic;  
   
    for (i = 0; i < MAX\_LINKS; i++) \{  
        if (rhashtable\_init(&nl\_table\[i\].hash,  
                    &netlink\_rhashtable\_params) < 0) \{  
            while (--i > 0)  
                rhashtable\_destroy(&nl\_table\[i\].hash);  
            kfree(nl\_table);  
            goto panic;  
        \}  
    \}  
   
    INIT\_LIST\_HEAD(&netlink\_tap\_all);  
   
    netlink\_add\_usersock\_entry();  
   
    sock\_register(&netlink\_family\_ops);  
    register\_pernet\_subsys(&netlink\_net\_ops);  
    /\* The netlink device handler may be needed early. \*/  
    rtnetlink\_init();  
out:  
    return err;  
panic:  
    panic("netlink\_init: Cannot allocate nl\_table\\n");  
\}  
   
core\_initcall(netlink\_proto\_init);  
本初始化函数首先向内核注册netlink协议；然后创建并初始化了nl\_table表数组，这个表是整个netlink实现的最关键的一步，每种协议类型占数组中的一项，后续内核中创建的不同种协议类型的netlink都将保存在这个表中，由该表统一维护，来简单看一些它的定义，有一个大概的印象：  
struct netlink\_table \{  
    struct rhashtable    hash;  
    struct hlist\_head    mc\_list;  
    struct listeners \_\_rcu    \*listeners;  
    unsigned int        flags;  
    unsigned int        groups;  
    struct mutex        \*cb\_mutex;  
    struct module        \*module;  
    int            (\*bind)(struct net \*net, int group);  
    void            (\*unbind)(struct net \*net, int group);  
    bool            (\*compare)(struct net \*net, struct sock \*sock);  
    int            registered;  
\};  
这里的hash（哈希表）用来索引同种协议类型的不同netlink套接字实例， mc\_list为多播使用的sock散列表，listeners为监听者掩码，groups为协议支持的最大多播组数量，同时还 定义了一些函数指针，它们会在内核首次创建netlink时被赋值，后续应用层创建和绑定socket时调用到。  
回到初始化函数中，接下来初始化应用层使用的NETLINK\_USERSOCK协议类型的netlink（用于应用层进程间通信）；然后调用sock\_register向内核注册协议处理函数，即将netlink的socket创建处理函数注册到内核中，如此以后应用层创建netlink类型的socket时将会调用该协议处理函数，其中netlink\_family\_ops函数的定义如下：  
static const struct net\_proto\_family netlink\_family\_ops = \{  
    .family = PF\_NETLINK,  
    .create = netlink\_create,  
    .owner    = THIS\_MODULE,    /\* for consistency 8) \*/  
\};  
这样以后应用层创建PF\_NETLINK(AF\_NETLINK)类型的socket()系统调用时将由netlink\_create()函数负责处理。  
再次回到初始化函数中，接下来调用register\_pernet\_subsys向内核所有的网络命名空间注册”子系统“的初始化和去初始化函数，这里的"子系统”并非指的是netlink子系统，而是一种通用的处理方式，在网络命名空间创建和注销时会调用这里注册的初始化和去初始化函数（当然对于已经存在的网络命名空间，在注册的过程中也会调用其初始化函数）， 后文中创建各种协议类型的netlink也是通过这种方式实现的。这里netlink\_net\_ops定义如下：  
static struct pernet\_operations \_\_net\_initdata netlink\_net\_ops = \{  
    .init = netlink\_net\_init,  
    .exit = netlink\_net\_exit,  
\};  
其中netlink\_net\_init()会在文件系统中位每个网络命名空间创建一个proc入口，而netlink\_net\_exit()就是则销毁之。下面回来看netlink\_proto\_init()初始化函数的最后，调用rtnetlink\_init()创建NETLINK\_ROUTE协议类型的netlink，该种类型的netlink才是当初内核设计netlink的初衷，它用来传递网络路由子系统、邻居子系统、接口设置、防火墙等消息。至此整个netlink子系统初始化完成，还是比较直观易懂的，接下来 就需要关注如何使用它进行通信了。

二、内核Netlink套接字  
内核中各种协议类型的netlink分别在不同的模块中进行创建和初始化，我以前文中的NETLINK\_ROUTE为例来分析一下内核中netlink套接字的创建流程。下面首先来看一下内核netlink使用到的几个关键数据结构：

1、内核netlink配置结构：struct netlink\_kernel\_cfg

/\* optional Netlink kernel configuration parameters \*/  
struct netlink\_kernel\_cfg \{  
    unsigned int    groups;  
    unsigned int    flags;  
    void        (\*input)(struct sk\_buff \*skb);  
    struct mutex    \*cb\_mutex;  
    int        (\*bind)(struct net \*net, int group);  
    void        (\*unbind)(struct net \*net, int group);  
    bool        (\*compare)(struct net \*net, struct sock \*sk);  
\};  
该结构包含了内核 netlink的可选参数。其中groups用于指定最大的多播组；flags成员可以为NL\_CFG\_F\_NONROOT\_RECV或NL\_CFG\_F\_NONROOT\_SEND，这两个符号前者用来限定非超级用户是否可以绑定到多播组，后者用来限定非超级用户是否可以发送组播；input指针用于指定回调函数，该回调函数用于接收和处理来自用户空间的消息（若无需接收来自用户空间的消息可不指定），最后的三个函数指针实现sock的绑定和解绑定等操作，会添加到nl\_table对应的项中去。  
2、netlink属性头：struct nlattr  
struct nlattr \{  
    \_\_u16           nla\_len;  
    \_\_u16           nla\_type;  
\};  
netlink的消息头后面跟着的是消息的有效载荷部分，它采用的是格式为“类型——长度——值”，简写TLV。其中类型和长度使用属性头nlattr来表示。其中nla\_len表示属性长度；nla\_type表示属性类型，它可以取值为以下几种类型（定义在include\\net\\ netlink.h中)：  
enum \{  
    NLA\_UNSPEC,  
    NLA\_U8,  
    NLA\_U16,  
    NLA\_U32,  
    NLA\_U64,  
    NLA\_STRING,  
    NLA\_FLAG,  
    NLA\_MSECS,  
    NLA\_NESTED,  
    NLA\_NESTED\_COMPAT,  
    NLA\_NUL\_STRING,  
    NLA\_BINARY,  
    NLA\_S8,  
    NLA\_S16,  
    NLA\_S32,  
    NLA\_S64,  
    \_\_NLA\_TYPE\_MAX,  
\};  
其中比较常用的NLA\_UNSPEC表示类型和长度未知、NLA\_U32表示无符号32位整形数、NLA\_STRING表示变长字符串、NLA\_NESTED表示嵌套属性（即包含一层 新的属性）。  
3、netlink有效性策略：struct nla\_policy  
struct nla\_policy \{  
    u16        type;  
    u16        len;  
\};  
netlink协议可以根据消息属性定义其特定的消息有效性策略，即对于某一种属性，该属性的期望类型是什么，内核将在收到消息以后对该消息的属性进行有效性判断（ 如果不设定len值，就不会执行有效性检查），只有判断一直的消息属性才算是合法的，否则只会默默的丢弃。这种有效性属性使用nla\_policy来描述，一般定义为一个有效性对象数组（当前这种netlink协议中的每一种attr属性（指定不是属性类型，而是用户定义的属性）有一个对应的数组项），这里type值同 struct nlattr中的nla\_type，len字段表示本属性的有效载荷长度。  
4、netlink套接字结构：netlink\_sock  
struct netlink\_sock \{  
    /\* struct sock has to be the first member of netlink\_sock \*/  
    struct sock        sk;  
    u32            portid;  
    u32            dst\_portid;  
    u32            dst\_group;  
    u32            flags;  
    u32            subscriptions;  
    u32            ngroups;  
    unsigned long        \*groups;  
    unsigned long        state;  
    size\_t            max\_recvmsg\_len;  
    wait\_queue\_head\_t    wait;  
    bool            bound;  
    bool            cb\_running;  
    struct netlink\_callback    cb;  
    struct mutex        \*cb\_mutex;  
    struct mutex        cb\_def\_mutex;  
    void            (\*netlink\_rcv)(struct sk\_buff \*skb);  
    int            (\*netlink\_bind)(struct net \*net, int group);  
    void            (\*netlink\_unbind)(struct net \*net, int group);  
    struct module        \*module;  
\#ifdef CONFIG\_NETLINK\_MMAP  
    struct mutex        pg\_vec\_lock;  
    struct netlink\_ring    rx\_ring;  
    struct netlink\_ring    tx\_ring;  
    atomic\_t        mapped;  
\#endif /\* CONFIG\_NETLINK\_MMAP \*/  
   
    struct rhash\_head    node;  
    struct rcu\_head        rcu;  
\};  
本结构用于描述一个netlink套接字，其中portid表示本套接字自己绑定的id号，对于内核来说它就是0，dst\_portid表示目的id号，ngroups表示协议支持多播组数量，groups保存组位掩码，netlink\_rcv保存接收到用户态数据后的处理函数，netlink\_bind和netlink\_unbind用于协议子协议自身特有的绑定和解绑定处理函数。  
5、创建内核netlink套接字  
现在查看rtnetlink\_net\_init()函数来分析NETLINK\_ROUTE类型netlink套接字的创建流程：首先回到子系统初始化函数netlink\_proto\_init()的最后，来查看rtnetlink\_init()函数的执行流程：

图2 内核netlink套接字创建流程

void \_\_init rtnetlink\_init(void)  
\{  
    if (register\_pernet\_subsys(&rtnetlink\_net\_ops))  
        panic("rtnetlink\_init: cannot initialize rtnetlink\\n");  
   
    ...  
\}  
这里的手法前文中已经见过了，这里将rtnetlink的init函数和exit函数注册到内核的每个网络命名空间中，对于已经存在的网络命名空间会调用其中个的init函数，这里就是rtnetlink\_net\_init()函数了。  
static struct pernet\_operations rtnetlink\_net\_ops = \{  
    .init = rtnetlink\_net\_init,  
    .exit = rtnetlink\_net\_exit,  
\};  
static int \_\_net\_init rtnetlink\_net\_init(struct net \*net)  
\{  
    struct sock \*sk;  
    struct netlink\_kernel\_cfg cfg = \{  
        .groups        = RTNLGRP\_MAX,  
        .input        = rtnetlink\_rcv,  
        .cb\_mutex    = &rtnl\_mutex,  
        .flags        = NL\_CFG\_F\_NONROOT\_RECV,  
    \};  
   
    sk = netlink\_kernel\_create(net, NETLINK\_ROUTE, &cfg);  
    if (!sk)  
        return -ENOMEM;  
    net->rtnl = sk;  
    return 0;  
\}  
首先这里定义了一个 netlink\_kernel\_cfg结构体实例，设置groups为RTNLGRP\_MAX后指定消息接收处理函数为rtnetlink\_rcv，并设置flag为NL\_CFG\_F\_NONROOT\_RECV，这表明非超级用户可以绑定到多播组，但是没有设置NL\_CFG\_F\_NONROOT\_SEND，这表明非超级用户将不能发送组播消息。  
随后init函数调用netlink\_kernel\_create()向当前的网络命名空间创建NETLINK\_ROUTE类型的套接字，并指定定义的那个配置结构cfg。进入 netlink\_kernel\_create()函数内部：  
netlink\_kernel\_create(struct net \*net, int unit, struct netlink\_kernel\_cfg \*cfg)  
\{  
    return \_\_netlink\_kernel\_create(net, unit, THIS\_MODULE, cfg);  
\}  
它其实就是\_\_netlink\_kernel\_create()的一个封装而已， \_\_netlink\_kernel\_create函数比较长，分段分析：  
/\*  
 \*    We export these functions to other modules. They provide a  
 \*    complete set of kernel non-blocking support for message  
 \*    queueing.  
 \*/  
   
struct sock \*  
\_\_netlink\_kernel\_create(struct net \*net, int unit, struct module \*module,  
            struct netlink\_kernel\_cfg \*cfg)  
\{  
    struct socket \*sock;  
    struct sock \*sk;  
    struct netlink\_sock \*nlk;  
    struct listeners \*listeners = NULL;  
    struct mutex \*cb\_mutex = cfg ? cfg->cb\_mutex : NULL;  
    unsigned int groups;  
   
    BUG\_ON(!nl\_table);  
   
    if (unit < 0 || unit >= MAX\_LINKS)  
        return NULL;  
   
    if (sock\_create\_lite(PF\_NETLINK, SOCK\_DGRAM, unit, &sock))  
        return NULL;  
   
    /\*  
     \* We have to just have a reference on the net from sk, but don't  
     \* get\_net it. Besides, we cannot get and then put the net here.  
     \* So we create one inside init\_net and the move it to net.  
     \*/  
   
    if (\_\_netlink\_create(&init\_net, sock, cb\_mutex, unit) < 0)  
        goto out\_sock\_release\_nosk;  
这里首先进行简单的参数判断之后就调用sock\_create\_lite()函数创建了一个以PF\_NETLINK为地址族的 SOCK\_DGRAM类型的 socket 套接字，其协议类型就是作为参数传入的NETLINK\_ROUTE。然后该函数调用最核心的 \_\_netlink\_create()函数向内核初始化netlink套接字 （其实在下文中将会看到用户态创建netlink套接字也是间接调用到该函数）：  
static int \_\_netlink\_create(struct net \*net, struct socket \*sock,  
                struct mutex \*cb\_mutex, int protocol)  
\{  
    struct sock \*sk;  
    struct netlink\_sock \*nlk;  
   
    sock->ops = &netlink\_ops;  
   
    sk = sk\_alloc(net, PF\_NETLINK, GFP\_KERNEL, &netlink\_proto);  
    if (!sk)  
        return -ENOMEM;  
   
    sock\_init\_data(sock, sk);  
   
    nlk = nlk\_sk(sk);  
    if (cb\_mutex) \{  
        nlk->cb\_mutex = cb\_mutex;  
    \} else \{  
        nlk->cb\_mutex = &nlk->cb\_def\_mutex;  
        mutex\_init(nlk->cb\_mutex);  
    \}  
    init\_waitqueue\_head(&nlk->wait);  
\#ifdef CONFIG\_NETLINK\_MMAP  
    mutex\_init(&nlk->pg\_vec\_lock);  
\#endif  
   
    sk->sk\_destruct = netlink\_sock\_destruct;  
    sk->sk\_protocol = protocol;  
    return 0;  
\}  
首先将sock的操作函数集指针设置为netlink\_ops，这在后面消息通讯时会详细分析，然后分配sock结构并进行初始化，主要包括初始化发送接收消息队列、数据缓存、等待队列和互斥锁等等，最后设置sk\_destruct回调函数和协议类型。再回到\_\_netlink\_kernel\_create()函数中继续分析：  
    sk = sock->sk;  
    sk\_change\_net(sk, net);  
   
    if (!cfg || cfg->groups < 32)  
        groups = 32;  
    else  
        groups = cfg->groups;  
   
    listeners = kzalloc(sizeof(\*listeners) + NLGRPSZ(groups), GFP\_KERNEL);  
    if (!listeners)  
        goto out\_sock\_release;  
   
    sk->sk\_data\_ready = netlink\_data\_ready;  
    if (cfg && cfg->input)  
        nlk\_sk(sk)->netlink\_rcv = cfg->input;  
   
    if (netlink\_insert(sk, 0))  
        goto out\_sock\_release;  
   
    nlk = nlk\_sk(sk);  
    nlk->flags |= NETLINK\_KERNEL\_SOCKET;  
这里有一点值得注意的就是前面在调用\_\_netlink\_create()时分配struct sock结构实例使用的是init\_net命名空间，这里会调用sk\_change\_net将网络命名空间转移回到当前的net命名空间（至于为什么要这样做，注释中有说明，大概意思是当前的上下文中无法对net命名空间执行get\_net操作，可能是防止内核还在初始化的过程中不支持这样的操作，具体原因还不是很理解）。  
接下来校验groups，默认最小支持32个组播地址（因为后文会看到用户层在绑定地址时最多绑定32个组播地址），但内核也有可能支持大于32个组播地址的情况（Genetlink就属于这种情况），然后分配listeners内存空间，这里边保存了监听者（监听套接字）的信息；接下来继续初始化函数指针，这里将前文中定义的rtnetlink\_rcv注册到了nlk\_sk(sk)->netlink\_rcv中，这样就设置完了内核态的消息处理函数；然后调用netlink\_insert()函数将本次创建的这个套接字添加到nl\_table中去（其核心是调用\_\_netlink\_insert()），注册的套接字是通过nl\_table中的哈希表来管理的。  
然后设置标识NETLINK\_KERNEL\_SOCKET表明这个netlink套接字是一个内核套接字。  
    netlink\_table\_grab();  
    if (!nl\_table\[unit\].registered) \{  
        nl\_table\[unit\].groups = groups;  
        rcu\_assign\_pointer(nl\_table\[unit\].listeners, listeners);  
        nl\_table\[unit\].cb\_mutex = cb\_mutex;  
        nl\_table\[unit\].module = module;  
        if (cfg) \{  
            nl\_table\[unit\].bind = cfg->bind;  
            nl\_table\[unit\].unbind = cfg->unbind;  
            nl\_table\[unit\].flags = cfg->flags;  
            if (cfg->compare)  
                nl\_table\[unit\].compare = cfg->compare;  
        \}  
        nl\_table\[unit\].registered = 1;  
    \} else \{  
        kfree(listeners);  
        nl\_table\[unit\].registered++;  
    \}  
    netlink\_table\_ungrab();  
    return sk;  
接下来继续初始化nl\_table表中对应传入 NETLINK\_ROUTE协议类型的数组项，首先会判断是否已经先有同样协议类型的已经注册过了，如果有就不再初始化该表项了，直接释放刚才申请的listeners内存空间然后递增注册个数并返回。这里假定是首次注册NETLINK\_ROUTE协议类型的套接字，这里依次初始化了nl\_table表项中的groups、listeners、cb\_mutex、module、bind、unbind、flags和compare字段。通过前文中cfg的实例分析，这里的初始化的值分别如下：  
nl\_table\[NETLINK\_ROUTE\].groups = RTNLGRP\_MAX;  
nl\_table\[NETLINK\_ROUTE\].cb\_mutex = &rtnl\_mutex;  
nl\_table\[ NETLINK\_ROUTE \].module = THIS\_MODULE;  
nl\_table\[NETLINK\_ROUTE\].bind = NULL;  
nl\_table\[NETLINK\_ROUTE\].unbind = NULL;  
nl\_table\[NETLINK\_ROUTE\].compare = NULL;  
nl\_table\[NETLINK\_ROUTE\].flags= NL\_CFG\_F\_NONROOT\_RECV;  
这些写值在后面的通信流程中就会使用到。在函数的最后返回成功创建的netlink套接字中的sock指针，它会在最先前的rtnetlink\_net\_init()函数中被保存到net->rtnl中去，注意只有NETLINK\_ROUTE协议类型的套接字才会执行这个步骤，因为网络命名空间中专门为其预留了一个sock指针。  
至此内核NETLINK\_ROUTE套接字创建完成，下面来看一下应用层是如何创建netlink套接字的。  
三、应用层Netlink套接字  
应用层通过标准的sock API即可使用Netlink完成通信功能（如socket()、sendto()、recv()、sendmsg()和recvmsg()等）。首先来看一些基本的数据结构及创建流程：

图3 用户层netlink套接字创建流程  
1、套接字地址数据结构sockaddr\_nl   
struct sockaddr\_nl \{  
    \_\_kernel\_sa\_family\_t    nl\_family;    /\* AF\_NETLINK    \*/  
    unsigned short    nl\_pad;        /\* zero        \*/  
    \_\_u32        nl\_pid;        /\* port ID    \*/  
           \_\_u32        nl\_groups;    /\* multicast groups mask \*/  
\};  
其中（1）nl\_family始终为AF\_NETLINK；（2）nl\_pad始终为0；（3）nl\_pid为netlink套接字的单播地址，在发送消息时用于表示目的套接字的地址，在用户空间绑定时可以指定为当前进程的PID号（对于内核来说这个值为0）或者干脆不设置（在绑定bind时由内核调用netlink\_autobind()设置为当前进程的PID），但需要注意的是当用户同一个进程中需要创建多个netlink套接字时则必须保证这个值是唯一的（一般在多线程中可以使用”pthread\_self() << 16 | getpid()“这样的方法进行设置）；（4）nl\_groups表示组播组。在发送消息时用于表示目的多播组，在绑定地址时用于表示加入的多播组。这里nl\_groups为一个32位无符号数，其中的每一位表示一个   多播组，一个netlink套接字可以加入多个多播组用以接收多个多播组的多播消息（最多支持32个）。

2、创建Netlink套接字  
应用层通过socket()系统调用创建Netlink套接字，socket系统调用的第一个参数可以是AF\_NETLINK或PF\_NETLINK（在Linux系统中它俩实际为同一种宏），第二个参数可以是SOCK\_RAW或SOCK\_DGRAM（原始套接字或无连接的数据报套接字），最后一个参为netlink.h中定义的协议类型，用户可以按需求自行创建上述不同种类的套接字。

例如调用 socket(AF\_NETLINK, SOCK\_RAW, NETLINK\_ROUTE) 即创建了一个NETLINK\_ROUTE类型的Netlink套接字。下面跟进这个系统调用，查看内核是如何为用户层创建这个套接字然后又做了哪些初始化动作：

SYSCALL\_DEFINE3(socket, int, family, int, type, int, protocol)  
\{  
    int retval;  
    struct socket \*sock;  
    int flags;  
   
    /\* Check the SOCK\_\* constants for consistency.  \*/  
    BUILD\_BUG\_ON(SOCK\_CLOEXEC != O\_CLOEXEC);  
    BUILD\_BUG\_ON((SOCK\_MAX | SOCK\_TYPE\_MASK) != SOCK\_TYPE\_MASK);  
    BUILD\_BUG\_ON(SOCK\_CLOEXEC & SOCK\_TYPE\_MASK);  
    BUILD\_BUG\_ON(SOCK\_NONBLOCK & SOCK\_TYPE\_MASK);  
   
    flags = type & ~SOCK\_TYPE\_MASK;  
    if (flags & ~(SOCK\_CLOEXEC | SOCK\_NONBLOCK))  
        return -EINVAL;  
    type &= SOCK\_TYPE\_MASK;  
   
    if (SOCK\_NONBLOCK != O\_NONBLOCK && (flags & SOCK\_NONBLOCK))  
        flags = (flags & ~SOCK\_NONBLOCK) | O\_NONBLOCK;  
   
    retval = sock\_create(family, type, protocol, &sock);  
    if (retval < 0)  
        goto out;  
   
    retval = sock\_map\_fd(sock, flags & (O\_CLOEXEC | O\_NONBLOCK));  
    if (retval < 0)  
        goto out\_release;  
   
out:  
    /\* It may be already another descriptor 8) Not kernel problem. \*/  
    return retval;  
   
out\_release:  
    sock\_release(sock);  
    return retval;  
\}  
该函数首先做了一些参数检查之后就调用sock\_create()函数创建套接字，在创建完成后向内核申请描述符并返回该描述符。进入sock\_create()函数内部，它是\_\_sock\_create()的一层封装（内核中往往前面带两个下划线的函数才是做事实的，嘿嘿），这里要注意的是调用时又多了两个个参数，一是当前进程绑定的网络命名空间，而是最后一个kern参数，这里传入0表明是从应用层创建的套接字。\_\_sock\_create()函数比较长，来分段分析之：  
int sock\_create(int family, int type, int protocol, struct socket \*\*res)  
\{  
    return \_\_sock\_create(current->nsproxy->net\_ns, family, type, protocol, res, 0);  
\}  
int \_\_sock\_create(struct net \*net, int family, int type, int protocol,  
             struct socket \*\*res, int kern)  
\{  
    int err;  
    struct socket \*sock;  
    const struct net\_proto\_family \*pf;  
   
    /\*  
     \*      Check protocol is in range  
     \*/  
    if (family < 0 || family >= NPROTO)  
        return -EAFNOSUPPORT;  
    if (type < 0 || type >= SOCK\_MAX)  
        return -EINVAL;  
   
    /\* Compatibility.  
       This uglymoron is moved from INET layer to here to avoid  
       deadlock in module load.  
     \*/  
    if (family == PF\_INET && type == SOCK\_PACKET) \{  
        static int warned;  
        if (!warned) \{  
            warned = 1;  
            pr\_info("%s uses obsolete (PF\_INET,SOCK\_PACKET)\\n",  
                current->comm);  
        \}  
        family = PF\_PACKET;  
    \}  
这里依然是一些入参判断，非常直观，无需分析，继续往下：  
    err = security\_socket\_create(family, type, protocol, kern);  
    if (err)  
        return err;  
   
    /\*  
     \*    Allocate the socket and allow the family to set things up. if  
     \*    the protocol is 0, the family is instructed to select an appropriate  
     \*    default.  
     \*/  
    sock = sock\_alloc();  
    if (!sock) \{  
        net\_warn\_ratelimited("socket: no more sockets\\n");  
        return -ENFILE;    /\* Not exactly a match, but its the  
                   closest posix thing \*/  
    \}  
   
    sock->type = type;  
首先对创建socket执行安全性检查，security\_socket\_create这个函数在内核没有启用CONFIG\_SECURITY\_NETWORK配置时是一个空函数直接返回0，这里先不考虑。接下来调用sock\_alloc()分配socket实例，它会为其创建和初始化索引节点（inode）。然后将sock->type赋值为传入的SOCK\_RAW。  
\#ifdef CONFIG\_MODULES  
    /\* Attempt to load a protocol module if the find failed.  
     \*  
     \* 12/09/1996 Marcin: But! this makes REALLY only sense, if the user  
     \* requested real, full-featured networking support upon configuration.  
     \* Otherwise module support will break!  
     \*/  
    if (rcu\_access\_pointer(net\_families\[family\]) == NULL)  
        request\_module("net-pf-%d", family);  
\#endif  
   
    rcu\_read\_lock();  
    pf = rcu\_dereference(net\_families\[family\]);  
    err = -EAFNOSUPPORT;  
    if (!pf)  
        goto out\_release;  
在启用内核模块的情况下，这里会到内核net\_families数组中查找该family（AF\_NETLINK）是否已经注册，如果没有注册就会尝试加载网络子系统模块。其实在内核的netlink初始化函数中已经调用sock\_register()完成注册了（见前文）。接下来从net\_families数组中获取已经注册的struct net\_proto\_family结构实例，这里就是第一节中描述过的netlink\_family\_ops了。继续往下分析：  
    /\*  
     \* We will call the ->create function, that possibly is in a loadable  
     \* module, so we have to bump that loadable module refcnt first.  
     \*/  
    if (!try\_module\_get(pf->owner))  
        goto out\_release;  
   
    /\* Now protected by module ref count \*/  
    rcu\_read\_unlock();  
   
    err = pf->create(net, sock, protocol, kern);  
    if (err < 0)  
        goto out\_module\_put;  
   
    /\*  
     \* Now to bump the refcnt of the \[loadable\] module that owns this  
     \* socket at sock\_release time we decrement its refcnt.  
     \*/  
    if (!try\_module\_get(sock->ops->owner))  
        goto out\_module\_busy;  
   
    /\*  
     \* Now that we're done with the ->create function, the \[loadable\]  
     \* module can have its refcnt decremented  
     \*/  
    module\_put(pf->owner);  
    err = security\_socket\_post\_create(sock, family, type, protocol, kern);  
    if (err)  
        goto out\_sock\_release;  
    \*res = sock;  
   
    return 0;  
这里先获取当前模块的引用计数并上锁，然后调用netlink协议的creat()钩子函数执行进一步的创建和初始化操作（这里就是netlink\_family\_ops中定义的netlink\_create()了），完成之后就释放锁同时释放当前模块的引用计数并返回创建成功的socket。下面进入netlink\_create()内部继续分析：  
static int netlink\_create(struct net \*net, struct socket \*sock, int protocol,  
              int kern)  
\{  
    struct module \*module = NULL;  
    struct mutex \*cb\_mutex;  
    struct netlink\_sock \*nlk;  
    int (\*bind)(struct net \*net, int group);  
    void (\*unbind)(struct net \*net, int group);  
    int err = 0;  
   
    sock->state = SS\_UNCONNECTED;  
   
    if (sock->type != SOCK\_RAW && sock->type != SOCK\_DGRAM)  
        return -ESOCKTNOSUPPORT;  
   
    if (protocol < 0 || protocol >= MAX\_LINKS)  
        return -EPROTONOSUPPORT;  
   
    netlink\_lock\_table();  
\#ifdef CONFIG\_MODULES  
    if (!nl\_table\[protocol\].registered) \{  
        netlink\_unlock\_table();  
        request\_module("net-pf-%d-proto-%d", PF\_NETLINK, protocol);  
        netlink\_lock\_table();  
    \}  
\#endif  
    if (nl\_table\[protocol\].registered &&  
        try\_module\_get(nl\_table\[protocol\].module))  
        module = nl\_table\[protocol\].module;  
    else  
        err = -EPROTONOSUPPORT;  
    cb\_mutex = nl\_table\[protocol\].cb\_mutex;  
    bind = nl\_table\[protocol\].bind;  
    unbind = nl\_table\[protocol\].unbind;  
    netlink\_unlock\_table();  
   
    if (err < 0)  
        goto out;  
   
    err = \_\_netlink\_create(net, sock, cb\_mutex, protocol);  
    if (err < 0)  
        goto out\_module;  
   
    local\_bh\_disable();  
    sock\_prot\_inuse\_add(net, &netlink\_proto, 1);  
    local\_bh\_enable();  
   
    nlk = nlk\_sk(sock->sk);  
    nlk->module = module;  
    nlk->netlink\_bind = bind;  
    nlk->netlink\_unbind = unbind;  
out:  
    return err;  
   
out\_module:  
    module\_put(module);  
    goto out;  
\}  
首先将socket的状态标记为未连接，判断套接字的类型是否是SOCK\_RAW或SOCK\_DGRAM类型的，若不是就不能继续创建；接着判断该协议类型的netlink是否已经注册了，由于前文中内核在初始化netlink子系统时已经初始化了NETLINK\_ROUTE内核套接字并向nl\_table注册，所以这里的几个赋值结果如下：

cb\_mutex = nl\_table\[NETLINK\_ROUTE\].cb\_mutex = &rtnl\_mutex;   
module = nl\_table\[NETLINK\_ROUTE\].module = THIS\_MODULE;  
bind = nl\_table\[NETLINK\_ROUTE\].bind = NULL;  
unbind = nl\_table\[NETLINK\_ROUTE\].unbind = NULL;

接下来将调用\_\_netlink\_create()完成核心的创建初始化，这个函数在前面已经分析过了，就不进入继续分析了。再往下调用sock\_prot\_inuse\_add添加协议的引用计数，最后完成赋值：

nlk->module = module = THIS\_MODULE ;  
nlk->netlink\_bind = bind = NULL;  
nlk->netlink\_unbind = unbind = NULL;  
至此用户态NETLINK\_ROUTE类型的套接字就创建完成了。  
3、绑定套接字  
在创建完成套接字后需要调用bind()函数进行绑定，将该套接字绑定到一个特定的地址或者加入一个多播组中，以后内核或其他应用层套接字向该地址单播或向该多播组发送组播消息时即可通过recv()或recvmsg()函数接收消息了。绑定地址时需要使用到sockaddr\_nl地址结构，如果使用使用单播则需要将地址本地地址信息填入nl\_pid变量并设置nl\_groups为0，如果使用多播则将nl\_pid设置为0并填充nl\_groups为多播地址，如下可将当前进程的PID号作为单播地址进行绑定：

struct sockaddr\_nl local;  
   
fd = socket(AF\_NETLINK, SOCK\_RAW, NETLINK\_ROUTE);  
memset(&local, 0, sizeof(local));  
local.nl\_family = AF\_NETLINK;  
local.nl\_pid = getpid();  
   
bind(fd, (struct sockaddr \*) &local, sizeof(local));  
其中bind()的第一个参数为刚创建的Netlink套接字描述符，第二个参数就是需要绑定的套接字地址，最后一个参数是地址的长度。这个绑定操作同创建TCP套接字类似，需要制定绑定的端口（或者由内核给指定一个亦可）。下面进入bind()系统调用分析整个绑定的过程：

图3 用户层netlink套接字绑定流程  
/\*  
 \*    Bind a name to a socket. Nothing much to do here since it's  
 \*    the protocol's responsibility to handle the local address.  
 \*  
 \*    We move the socket address to kernel space before we call  
 \*    the protocol layer (having also checked the address is ok).  
 \*/  
   
SYSCALL\_DEFINE3(bind, int, fd, struct sockaddr \_\_user \*, umyaddr, int, addrlen)  
\{  
    struct socket \*sock;  
    struct sockaddr\_storage address;  
    int err, fput\_needed;  
   
    sock = sockfd\_lookup\_light(fd, &err, &fput\_needed);  
    if (sock) \{  
        err = move\_addr\_to\_kernel(umyaddr, addrlen, &address);  
        if (err >= 0) \{  
            err = security\_socket\_bind(sock,  
                           (struct sockaddr \*)&address,  
                           addrlen);  
            if (!err)  
                err = sock->ops->bind(sock,  
                              (struct sockaddr \*)  
                              &address, addrlen);  
        \}  
        fput\_light(sock->file, fput\_needed);  
    \}  
    return err;  
\}  
首先根据用户传入的fd文件描述符向内核查找对应的socket结构，然后将用户空间传入的地址struct sockaddr拷贝到内核中（会使用到copy\_from\_user()），接下来继续跳过安全检查函数security\_socket\_bind()，剩下的主要工作就交给了sock->ops->bind()注册函数了。在创建套接字时调用的\_\_netlink\_create()函数中已经将sock->ops赋值为netlink\_ops了，来看一下这个结构实例：  
static const struct proto\_ops netlink\_ops = \{  
    .family =    PF\_NETLINK,  
    .owner =    THIS\_MODULE,  
    .release =    netlink\_release,  
    .bind =        netlink\_bind,  
    .connect =    netlink\_connect,  
    .socketpair =    sock\_no\_socketpair,  
    .accept =    sock\_no\_accept,  
    .getname =    netlink\_getname,  
    .poll =        netlink\_poll,  
    .ioctl =    sock\_no\_ioctl,  
    .listen =    sock\_no\_listen,  
    .shutdown =    sock\_no\_shutdown,  
    .setsockopt =    netlink\_setsockopt,  
    .getsockopt =    netlink\_getsockopt,  
    .sendmsg =    netlink\_sendmsg,  
    .recvmsg =    netlink\_recvmsg,  
    .mmap =        netlink\_mmap,  
    .sendpage =    sock\_no\_sendpage,  
\};  
这个结构中的各个函数指针都会由系统调用根据套接字的协议类型间接调用到，此时就会调用到这里的netlink\_bind()函数，这个函数较长，分段分析：  
static int netlink\_bind(struct socket \*sock, struct sockaddr \*addr,  
            int addr\_len)  
\{  
    struct sock \*sk = sock->sk;  
    struct net \*net = sock\_net(sk);  
    struct netlink\_sock \*nlk = nlk\_sk(sk);  
    struct sockaddr\_nl \*nladdr = (struct sockaddr\_nl \*)addr;  
    int err;  
    long unsigned int groups = nladdr->nl\_groups;  
    bool bound;  
   
    if (addr\_len < sizeof(struct sockaddr\_nl))  
        return -EINVAL;  
   
    if (nladdr->nl\_family != AF\_NETLINK)  
        return -EINVAL;  
   
    /\* Only superuser is allowed to listen multicasts \*/  
    if (groups) \{  
        if (!netlink\_allowed(sock, NL\_CFG\_F\_NONROOT\_RECV))  
            return -EPERM;  
        err = netlink\_realloc\_groups(sk);  
        if (err)  
            return err;  
    \}  
可以看到，这里又将用户传入的地址类型强制转换成了sockaddr\_nl类型的地址结构，然后做了一些参数的判断，接着如果用户设定了需要绑定的多播地址，这里会去检擦nl\_table中注册的套接字是否已经设置了NL\_CFG\_F\_NONROOT\_RECV标识，如果没有设置将拒绝用户绑定到组播组，显然在前文中已经看到了NETLINK\_ROUTE类型的套接字是设置了这个标识的，所以这里会调用netlink\_realloc\_groups分配组播空间，进入看一下：  
static int netlink\_realloc\_groups(struct sock \*sk)  
\{  
    struct netlink\_sock \*nlk = nlk\_sk(sk);  
    unsigned int groups;  
    unsigned long \*new\_groups;  
    int err = 0;  
   
    netlink\_table\_grab();  
   
    groups = nl\_table\[sk->sk\_protocol\].groups;  
    if (!nl\_table\[sk->sk\_protocol\].registered) \{  
        err = -ENOENT;  
        goto out\_unlock;  
    \}  
   
    if (nlk->ngroups >= groups)  
        goto out\_unlock;  
   
    new\_groups = krealloc(nlk->groups, NLGRPSZ(groups), GFP\_ATOMIC);  
    if (new\_groups == NULL) \{  
        err = -ENOMEM;  
        goto out\_unlock;  
    \}  
    memset((char \*)new\_groups + NLGRPSZ(nlk->ngroups), 0,  
           NLGRPSZ(groups) - NLGRPSZ(nlk->ngroups));  
   
    nlk->groups = new\_groups;  
    nlk->ngroups = groups;  
 out\_unlock:  
    netlink\_table\_ungrab();  
    return err;  
\}  
这里会比较验证一下当前套接字中指定的组播地址上限是否大于NETLINK\_ROUTE套接字支持的最大地址（这里为RTNLGRP\_MAX），由于这个套接字是前面刚刚创建的，所以nlk->ngroups = 0。  
然后为其分配内存空间，分配的空间大小为NLGRPSZ(groups)（这是一个取整对齐的宏），分配完成后将新分配的空间清零，首地址保存在nlk->groups中，最后更新nlk->ngroups变量。回到netlink\_bind()函数中继续往下分析：  
    bound = nlk->bound;  
    if (bound) \{  
        /\* Ensure nlk->portid is up-to-date. \*/  
        smp\_rmb();  
   
        if (nladdr->nl\_pid != nlk->portid)  
            return -EINVAL;  
    \}  
   
    if (nlk->netlink\_bind && groups) \{  
        int group;  
   
        for (group = 0; group < nlk->ngroups; group++) \{  
            if (!test\_bit(group, &groups))  
                continue;  
            err = nlk->netlink\_bind(net, group + 1);  
            if (!err)  
                continue;  
            netlink\_undo\_bind(group, groups, sk);  
            return err;  
        \}  
    \}  
接下来如果已经绑定过了，会检查新需要绑定的id号是否等于已经绑定的id号，若不相等则返回失败。接着如果netlink套接字子协议存在特有的bind函数且用户指定了需要绑定的组播地址，则调用之为其绑定到特定的组播组中去。现由于NETLINK\_ROUTE套接字并不存在nlk->netlink\_bind()函数实现，所以这里并不会调用。  
    /\* No need for barriers here as we return to user-space without  
     \* using any of the bound attributes.  
     \*/  
    if (!bound) \{  
        err = nladdr->nl\_pid ?  
            netlink\_insert(sk, nladdr->nl\_pid) :  
            netlink\_autobind(sock);  
        if (err) \{  
            netlink\_undo\_bind(nlk->ngroups, groups, sk);  
            return err;  
        \}  
    \}  
如果本套接字并没有被绑定过（目前就是这种情况），这里会根据用户是否指定了单播的绑定地址来调用不同的函数。首先假定用户空间指定了单播的绑定地址，这里会调用netlink\_insert()函数将这个套接字插入到nl\_table\[NETLINK\_ROUTE\]数组项的哈希表中去，同时设置nlk\_sk(sk)->bound = nlk\_sk(sk)->portid = nladdr->nl\_pid。我们再假定用户空间没有设置单播的绑定地址，这里会调用netlink\_autobind()动态的绑定一个地址，进入该函数简单的看一下：  
static int netlink\_autobind(struct socket \*sock)  
\{  
    struct sock \*sk = sock->sk;  
    struct net \*net = sock\_net(sk);  
    struct netlink\_table \*table = &nl\_table\[sk->sk\_protocol\];  
    s32 portid = task\_tgid\_vnr(current);  
    int err;  
    static s32 rover = -4097;  
   
retry:  
    cond\_resched();  
    rcu\_read\_lock();  
    if (\_\_netlink\_lookup(table, portid, net)) \{  
        /\* Bind collision, search negative portid values. \*/  
        portid = rover--;  
        if (rover > -4097)  
            rover = -4097;  
        rcu\_read\_unlock();  
        goto retry;  
    \}  
    rcu\_read\_unlock();  
   
    err = netlink\_insert(sk, portid);  
    if (err == -EADDRINUSE)  
        goto retry;  
   
    /\* If 2 threads race to autobind, that is fine.  \*/  
    if (err == -EBUSY)  
        err = 0;  
   
    return err;  
\}  
这里会首先尝试选用当前的进程ID作为端口地址，如果当前进程ID已经绑定过其他的相同protocol套接字则会选用一个负数作为ID号（查找直到存在可用的），最后同样调用netlink\_insert()函数。回到netlink\_bind()函数中：  
    if (!groups && (nlk->groups == NULL || !(u32)nlk->groups\[0\]))  
        return 0;  
   
    netlink\_table\_grab();  
    netlink\_update\_subscriptions(sk, nlk->subscriptions +  
                     hweight32(groups) -  
                     hweight32(nlk->groups\[0\]));  
    nlk->groups\[0\] = (nlk->groups\[0\] & ~0xffffffffUL) | groups;  
    netlink\_update\_listeners(sk);  
    netlink\_table\_ungrab();  
   
    return 0;  
如果没有指定组播地址且没有分配组播的内存，绑定工作到这里就已经结束了，可以直接返回了。现假定用户指定了需要绑定的组播地址，这里首先调用netlink\_update\_subscriptions绑定sk->sk\_bind\_node到nl\_table\[sk->sk\_protocol\].mc\_list中，同时将加入的组播组数目记录到nlk->subscriptions中，并将组播地址保存到nlk->groups\[0\]中，最后更新netlink监听位掩码。至此绑定操作结束。  
分析完成netlink子系统的创建、内核netlink套接字的创建、应用层netlink套接字的创建和绑定后，下一篇来分析一下内核和应用层之间是如何发送消息的。

参考文献：《Linux Kernel Networking Implementation and Theory》