netlink 009 -- Generic Netlink初始化

﹏ヽ暗。殇╰゛Y 2021-11-02 10:32 241阅读 0赞

Generic Netlink 是内核专门为了扩展netlink协议簇而设计的“通用netlink协议簇”。由于netlink协议最多支持32个协议簇，目前Linux4.1的内核中已经使用其中21个，对于用户需要定制特殊的协议类型略显不够，而且用户还需自行在include/linux/netlink.h中添加簇定义（略显不妥），为此Linux设计了这种通用Netlink协议簇，用户可在此之上定义更多类型的子协议。前两篇博文已经较为详细的分析了netlink的创建和通信流程，本文以Generic Netlink为例首先来深入分析一下netlink的消息结构及创建初始化流程。

Generic Netlink使用NETLINK\_GENERIC类型协议簇，同样基于netlink子系统。具体框架如下：

![Center][]

图1 Generic Netlink模型框架

其中Ctrl控制器是一种特殊类型的Genetlink协议族，它用于用户空间通过Genetlink簇名查找对应的ID号，后文中会详细分析。

Generic Netlink的消息结构基于netlink消息结构并在此基础上继续扩展，首先来看一下netlink类型的消息结构（见include/net/netlink.h）：

/* ========================================================================
     *         Netlink Messages and Attributes Interface (As Seen On TV)
     * ------------------------------------------------------------------------
     *                          Messages Interface
     * ------------------------------------------------------------------------
     *
     * Message Format:
     *    <--- nlmsg_total_size(payload)  --->
     *    <-- nlmsg_msg_size(payload) ->
     *   +----------+- - -+-------------+- - -+-------- - -
     *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
     *   +----------+- - -+-------------+- - -+-------- - -
     *   nlmsg_data(nlh)---^                   ^
     *   nlmsg_next(nlh)-----------------------+
     *
     * Payload Format:
     *    <---------------------- nlmsg_len(nlh) --------------------->
     *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
     *   +----------------------+- - -+--------------------------------+
     *   |     Family Header    | Pad |           Attributes           |
     *   +----------------------+- - -+--------------------------------+
     *   nlmsg_attrdata(nlh, hdrlen)---^
     *
     * Attribute Format:
     *    <------- nla_total_size(payload) ------->
     *    <---- nla_attr_size(payload) ----->
     *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
     *   |  Header  | Pad |     Payload      | Pad |  Header
     *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
     *                     <- nla_len(nla) ->      ^
     *   nla_data(nla)----^                        |
     *   nla_next(nla)-----------------------------'
     *
     *=========================================================================

首先最上层，一个netlink消息有netlink消息头和netlink消息载荷组成，它们之间存在内存对齐的pad留空空间（这在《Netlink 内核实现分析（1）（2）》中已经看到了，但并未对消息载荷进行进一步分析）；然后往下一级消息的实际载荷又可分为family头级具体的消息属性，其中family头针对不同协议种类的netlink定义各部相同；到最底层消息属性又分为消息属性头和实际的消息载荷。Genetlink消息基于这个消息结构类型并定制化为如下结构：

![Center 1][]

图2 Generic Netlink消息结构  
其中family头对于Genetlink来说就是Generic消息头genlmsghdr，接下来是可选的用户特定消息头，最后才是可选的有效载荷，即一个个消息属性实例。

Genetlink消息是命令驱动式的，即每一条消息的genlmsghdr中都指明了当前消息的cmd消息命令，这些消息cmd命令由用户自行定义。内核在接收到用户的genl消息后，首先会对命令cmd做判断，找到对应的消息处理结构（可能会执行attr有效性检查），然后才会去调用消息处理回调函数从消息载荷区中读取并处理其所需要的的attr属性载荷。

一、Generic Netlink相关结构体  
1、Generic Netlink消息头结构：struct genlmsghdr  
struct genlmsghdr \{  
    \_\_u8    cmd;  
    \_\_u8    version;  
    \_\_u16    reserved;  
\};  
Generic Netlink消息头比较简单，仅包含了两个字段。其中cmd表示消息命令，对于用户自己定义的每个子协议类型都需要定义特定的消息命令集，这里该字段表示当前消息的消息命令；version字段表示版本控制（可以在在不破坏向后兼容性的情况下修改消息的格式），可以不使用该字段；最后的reserved字段保留。  
2、Generic Netlink Family结构：struct genl\_family（内核中完成注册）  
struct genl\_family \{  
    unsigned int        id;  
    unsigned int        hdrsize;  
    char            name\[GENL\_NAMSIZ\];  
    unsigned int        version;  
    unsigned int        maxattr;  
    bool            netnsok;  
    bool            parallel\_ops;  
    int            (\*pre\_doit)(const struct genl\_ops \*ops,  
                        struct sk\_buff \*skb,  
                        struct genl\_info \*info);  
    void            (\*post\_doit)(const struct genl\_ops \*ops,  
                         struct sk\_buff \*skb,  
                         struct genl\_info \*info);  
    int            (\*mcast\_bind)(struct net \*net, int group);  
    void            (\*mcast\_unbind)(struct net \*net, int group);  
    struct nlattr \*\*    attrbuf;    /\* private \*/  
    const struct genl\_ops \*    ops;        /\* private \*/  
    const struct genl\_multicast\_group \*mcgrps; /\* private \*/  
    unsigned int        n\_ops;        /\* private \*/  
    unsigned int        n\_mcgrps;    /\* private \*/  
    unsigned int        mcgrp\_offset;    /\* private \*/  
    struct list\_head    family\_list;    /\* private \*/  
    struct module        \*module;  
\};  
Generic Netlink按照family进行管理，用户需注册自己定义的genl\_family结构，同时内核使用一个哈希表family\_ht对已经注册的genl family进行管理。各字段的含义如下：

id：genl family的ID号，一般由内核进行分配，取值范围为GENL\_MIN\_ID~GENL\_MAX\_ID（16~1023），其中GENL\_ID\_CTRL为控制器的family ID，不可另行分配，该familyID全局唯一并且在family\_ht中的位置也由该值确定；

hdrsize：用户私有报头的长度，即可选的user msg header长度，若没有则为0；

name：genl family的名称，必须是独一无二且用户层已知的（用户通过它来向控制查找family id）；

version：版本号；

maxattr：消息属性attr最大的类型数（即该genl family所支持的最大attr属性类型的种类个数）；

netnsok：指示当前簇是否能够处理网络命名空间；

pre\_doit：调用genl\_ops结构中处理消息函数doit()前调用的钩子函数，一般用于执行一些前置的当前簇通用化处理，例如对临界区加锁等；

post\_doit：调用genl\_ops结构中处理消息函数doit()后调用的钩子函数，一般执行pre\_doit函数相反的操作；

mcast\_bind/mcast\_unbind：在绑定/解绑定socket到一个特定的genl netlink组播组中调用（目前内核中没有相关使用）；

attrbuf：保存拷贝的attr属性缓存；

ops/n\_ops：保存genl family命令处理结构即命令的个数，后面详细描述；

family\_list：链表结构，用于将当前当前簇链入全局family\_ht散列表中；

mcgrps/n\_mcgrps：保存当前簇使用的组播组及组播地址的个数；

3、Generic Netlink Family命令处理结构：struct genl\_ops（内核中完成注册）  
struct genl\_ops \{  
    const struct nla\_policy    \*policy;  
    int               (\*doit)(struct sk\_buff \*skb,  
                       struct genl\_info \*info);  
    int               (\*dumpit)(struct sk\_buff \*skb,  
                     struct netlink\_callback \*cb);  
    int               (\*done)(struct netlink\_callback \*cb);  
    u8            cmd;  
    u8            internal\_flags;  
    u8            flags;  
\};  
该结构用于注册genl family的用户命令cmd处理函数（对于只向应用层发送消息的簇可以不用实现和注册该结构），各个字段的含义如下：

cmd：簇命令类型，由用户自行根据需要定义；

internal\_flags：簇私有标识，用于进行一些分支处理，可以不使用；

flags：操作标识，有以下四种类型（在genetlink.h中定义）：

\#define GENL\_ADMIN\_PERM        0x01    /\* 当设置该标识时表示本命令操作需要具有CAP\_NET\_ADMIN权限 \*/  
\#define GENL\_CMD\_CAP\_DO        0x02    /\* 当genl\_ops结构中实现了doit()回调函数则设置该标识 \*/  
\#define GENL\_CMD\_CAP\_DUMP    0x04    /\* 当genl\_ops结构中实现了dumpit()回调函数则设置该标识 \*/  
\#define GENL\_CMD\_CAP\_HASPOL    0x08    /\* 当genl\_ops结构中定义了属性有效性策略（nla\_policy）则设置该标识 \*/  
policy：属性attr有效性策略，该结构定义在《Netlink内核实现分析（一）》种已经见过了，若该字段不为空，在genl执行消息处理函数前会对消息中的attr属性进行校验，否则则不做校验；  
doit：标准命令回调函数，在当前族中收到数据时触发调用，函数的第一个入参skb中保存了用户下发的消息内容；

dumpit：转储回调函数，当genl\_ops的flag标志被添加了NLM\_F\_DUMP以后会调用该回调函数，这里的第一个入参skb中不再有用户下发消息内容，而是要求函数能够在传入的skb中填入消息载荷并返回填入数据长度；

done：转储结束后执行的回调函数；

4、Generic Netlink Family内核接收消息结构：struct genl\_info  
struct genl\_info \{  
    u32            snd\_seq;  
    u32            snd\_portid;  
    struct nlmsghdr \*    nlhdr;  
    struct genlmsghdr \*    genlhdr;  
    void \*            userhdr;  
    struct nlattr \*\*    attrs;  
    possible\_net\_t        \_net;  
    void \*            user\_ptr\[2\];  
    struct sock \*        dst\_sk;  
\};  
内核在接收到用户的genetlink消息后，会对消息解析并封装成genl\_info结构，便于命令回校函数进行处理，其中各字段含义如下：  
snd\_seq：消息的发送序号（不强制使用）；

snd\_portid：消息发送端socket所绑定的ID；

nlhdr：netlink消息头；

genlhdr：generic netlink消息头；

userhdr：用户私有报头；

attrs：netlink属性，包含了消息的实际载荷；

dst\_sk：目的socket；

二、Generic Netlink初始化  
Generic Netlink只是中特殊类型的Netlink，它本质上还是依赖于netlink的内核机制，相关的函数在genetlink.c中，由genl\_init()启动初始化流程：

![Center 2][]

图3 Genetic Netlink初始化流程

static int \_\_init genl\_init(void)  
\{  
    int i, err;  
   
    for (i = 0; i < GENL\_FAM\_TAB\_SIZE; i++)  
        INIT\_LIST\_HEAD(&family\_ht\[i\]);  
   
    err = genl\_register\_family\_with\_ops\_groups(&genl\_ctrl, genl\_ctrl\_ops,  
                           genl\_ctrl\_groups);  
    if (err < 0)  
        goto problem;  
   
    err = register\_pernet\_subsys(&genl\_pernet\_ops);  
    if (err)  
        goto problem;  
   
    return 0;  
   
problem:  
    panic("GENL: Cannot register controller: %d\\n", err);  
\}  
首先初始化用于保存和维护Generic netlink family的散列表family\_ht数组，然后调用genl\_register\_family\_with\_ops\_groups向内核Generic netlink子系统注册控制器簇类型的Genetlink Family，首先来看一下genl\_ctrl的定义：  
static struct genl\_family genl\_ctrl = \{  
    .id = GENL\_ID\_CTRL,  
    .name = "nlctrl",  
    .version = 0x2,  
    .maxattr = CTRL\_ATTR\_MAX,  
    .netnsok = true,  
\};  
这里的ID为GENL\_ID\_CTRL(16)，即分配区间的最小值，maxattr定义为支持的attr属性最大个数CTRL\_ATTR\_MAX，该值定义如下：  
enum \{  
    CTRL\_ATTR\_UNSPEC,  
    CTRL\_ATTR\_FAMILY\_ID,  
    CTRL\_ATTR\_FAMILY\_NAME,  
    CTRL\_ATTR\_VERSION,  
    CTRL\_ATTR\_HDRSIZE,  
    CTRL\_ATTR\_MAXATTR,  
    CTRL\_ATTR\_OPS,  
    CTRL\_ATTR\_MCAST\_GROUPS,  
    \_\_CTRL\_ATTR\_MAX,  
\};  
   
\#define CTRL\_ATTR\_MAX(\_\_CTRL\_ATTR\_MAX - 1)  
这里为genetlink控制器定义了以CTRL\_ATTR\_UNSPEC为开头到最后的\_\_CTRL\_ATTR\_MAX中的一共7个attr属性类型，后文再进行分析；继续回到genl\_ctrl中，最后netnsok字段为true表示支持net命名空间。  
再来看一下genl\_ctrl\_ops的定义：

static struct genl\_ops genl\_ctrl\_ops\[\] = \{  
    \{  
        .cmd        = CTRL\_CMD\_GETFAMILY,  
        .doit        = ctrl\_getfamily,  
        .dumpit        = ctrl\_dumpfamily,  
        .policy        = ctrl\_policy,  
    \},  
\};  
这里为控制器类型的genetlink family只定义了一种cmd类型的内核操作接口，即CTRL\_CMD\_GETFAMILY，它用于应用空间从内核中获取指定family名称的ID号。因为该ID号在内核注册family时由内核进行分配，应用空间一般只知道需要通信的family name，但是要发起通信就必须知道该ID号，所以内核设计了控制器类型的family并定义了CTRL\_CMD\_GETFAMILY命令的处理接口用于应用程序查找ID号。  
然后指明doit和dumpit回调函数为ctrl\_getfamily和ctrl\_dumpfamily，最后指定attr有效性策略为ctrl\_policy：  
static const struct nla\_policy ctrl\_policy\[CTRL\_ATTR\_MAX+1\] = \{  
    \[CTRL\_ATTR\_FAMILY\_ID\]    = \{ .type = NLA\_U16 \},  
    \[CTRL\_ATTR\_FAMILY\_NAME\]    = \{ .type = NLA\_NUL\_STRING,  
                    .len = GENL\_NAMSIZ - 1 \},  
\};  
这里为CTRL\_ATTR\_FAMILY\_ID属性限定类型为16位无符号数，为CTRL\_ATTR\_FAMILY\_NAME属性限定为空结尾的字符串类型并限定了长度。  
最后来看一下注册的组播组：  
static struct genl\_multicast\_group genl\_ctrl\_groups\[\] = \{  
\{ .name = "notify", \},  
\};  
这里添加了name为”notify“的组播组。然后进入genl\_register\_family\_with\_ops\_groups内部来分析一下内核是如何注册这个family簇的：

\#define genl\_register\_family\_with\_ops\_groups(family, ops, grps)    \\  
    \_genl\_register\_family\_with\_ops\_grps((family),            \\  
                        (ops), ARRAY\_SIZE(ops),    \\  
                        (grps), ARRAY\_SIZE(grps))  
static inline int  
\_genl\_register\_family\_with\_ops\_grps(struct genl\_family \*family,  
                    const struct genl\_ops \*ops, size\_t n\_ops,  
                    const struct genl\_multicast\_group \*mcgrps,  
                    size\_t n\_mcgrps)  
\{  
    family->module = THIS\_MODULE;  
    family->ops = ops;  
    family->n\_ops = n\_ops;  
    family->mcgrps = mcgrps;  
    family->n\_mcgrps = n\_mcgrps;  
    return \_\_genl\_register\_family(family);  
\}  
这里根据入参初始化了family的ops等字段，然后调用\_\_genl\_register\_family()继续进行注册  
int \_\_genl\_register\_family(struct genl\_family \*family)  
\{  
    int err = -EINVAL, i;  
   
    if (family->id && family->id < GENL\_MIN\_ID)  
        goto errout;  
   
    if (family->id > GENL\_MAX\_ID)  
        goto errout;  
首先对入参的ID号进行判断，一般来说，为了保证ID号的全局唯一性，程序中一般都设置为GENL\_ID\_GENERATE，由内核统一分配（当然这里注册控制器family除外了）。  
    err = genl\_validate\_ops(family);  
    if (err)  
        return err;  
   
    genl\_lock\_all();  
   
    if (genl\_family\_find\_byname(family->name)) \{  
        err = -EEXIST;  
        goto errout\_locked;  
    \}  
接下来调用genl\_validate\_ops对ops函数集做校验，对于每一个注册的genl\_ops结构，其中doit和dumpit回调函数必须至少实现一个，然后其针对的cmd命令不可以出现重复，否则返回错误，注册失败。然后上锁开始启动链表操作，首先需要确保的是family name的全局唯一性，因此这里会查找是否有同名的簇已经注册了，若有就不能再注册了。  
    if (family->id == GENL\_ID\_GENERATE) \{  
        u16 newid = genl\_generate\_id();  
   
        if (!newid) \{  
            err = -ENOMEM;  
            goto errout\_locked;  
        \}  
   
        family->id = newid;  
    \} else if (genl\_family\_find\_byid(family->id)) \{  
        err = -EEXIST;  
        goto errout\_locked;  
    \}  
然后判断传入的ID号是否为GENL\_ID\_GENERATE，若是则由内核分配一个空闲的ID号，否则得确保程序指定的ID号没有被使用过。  
    if (family->maxattr && !family->parallel\_ops) \{  
        family->attrbuf = kmalloc((family->maxattr+1) \*  
                    sizeof(struct nlattr \*), GFP\_KERNEL);  
        if (family->attrbuf == NULL) \{  
            err = -ENOMEM;  
            goto errout\_locked;  
        \}  
    \} else  
        family->attrbuf = NULL;  
接着根据注册的最大attr参数maxattr，这里对于genl\_ctrl来说一共分配了CTRL\_ATTR\_MAX+1个指针内存空间，以后用于缓存attr属性（注意仅仅是保存属性的地址而非内容）。  
    err = genl\_validate\_assign\_mc\_groups(family);  
    if (err)  
        goto errout\_locked;  
然后调用genl\_validate\_assign\_mc\_groups()函数判断新增组播地址空间，该函数一共做了3件事：（1）判断注册family的group组播名的有效性；（2）为该family分配组播地址比特位并将bit偏移保存到family->mcgrp\_offset变量中（由于generic netlink中不同类型的family簇共用NETLINK\_GENERIC协议类型的group组播地址空间，因此内核特别维护了几个全局变量mc\_groups\_longs、mc\_groups和mc\_group\_start用以维护组播地址的比特位，另外对于几种特殊的family是已经分配了的。无需再行分配，例如这里的crtl控制器）；（3）更新全局nl\_table对应的NETLINK\_GENERIC协议类型netlink的groups标识。  
继续回到中\_\_genl\_register\_family()函数中：  
    list\_add\_tail(&family->family\_list, genl\_family\_chain(family->id));  
    genl\_unlock\_all();  
   
    /\* send all events \*/  
    genl\_ctrl\_event(CTRL\_CMD\_NEWFAMILY, family, NULL, 0);  
    for (i = 0; i < family->n\_mcgrps; i++)  
        genl\_ctrl\_event(CTRL\_CMD\_NEWMCAST\_GRP, family,  
                &family->mcgrps\[i\], family->mcgrp\_offset + i);  
   
    return 0;  
   
errout\_locked:  
    genl\_unlock\_all();  
errout:  
    return err;  
\}  
EXPORT\_SYMBOL(\_\_genl\_register\_family);  
接下来将family注册到链表中，最后调用genl\_ctrl\_event()函数向内核的控制器family发送CTRL\_CMD\_NEWFAMILY和CTRL\_CMD\_NEWMCAST\_GRP命令消息，当然这里本身就是在创建ctrl控制器family，所以该函数不会做任何的事情，对于注册其他通用family的情况后续在分析，这样ctrl familu就成功创建完成了。  
最后再回到genl\_init()中，接下来使用了register\_pernet\_subsys方法为当前系统中的网络命名空间创建Generic Netlink套接字：

static int \_\_net\_init genl\_pernet\_init(struct net \*net)  
\{  
    struct netlink\_kernel\_cfg cfg = \{  
        .input        = genl\_rcv,  
        .flags        = NL\_CFG\_F\_NONROOT\_RECV,  
        .bind        = genl\_bind,  
        .unbind        = genl\_unbind,  
    \};  
   
    /\* we'll bump the group number right afterwards \*/  
    net->genl\_sock = netlink\_kernel\_create(net, NETLINK\_GENERIC, &cfg);  
   
    if (!net->genl\_sock && net\_eq(net, &init\_net))  
        panic("GENL: Cannot initialize generic netlink\\n");  
   
    if (!net->genl\_sock)  
        return -ENOMEM;  
   
    return 0;  
\}  
这里定义了genetlink内核套接字的配置，并指定了消息处理函数为genl\_rcv()，套接字绑定和解绑定函数为genl\_bind()和genl\_unbind()（这点需要注意，和NETLINK\_ROUTE不同），随后调用netlink\_kernel\_create()函数完成内核套接字的注册（netlink\_kernel\_create函数在前篇博文中已经详细分析过了），并将生成的套接字赋值到网络命名空间net的genl\_sock中，以后就可以通过net->genl\_sock来找到genetlink内核套接字了。

本文分析了内核Generic Netlink的消息结构以及创建初始化流程，下一篇来根据一个具体的示例domo程序跟踪分析Generic netlink消息在内核中的通信及处理流程。

参考文献：1、《Linux Kernel Networking Implementation and Theory》；2、《Generic Netlink详解》

[Center]: /images/20211101/e11c86ab0ede4e6ea9d6a16a64489c51.png
[Center 1]: /images/20211101/11b98505a822472190d56c49b3d2d6ec.png
[Center 2]: /images/20211101/5bc3467a18364e2585602ab8e8c43b40.png