linux的netlink接口详解（下）

——linux版本： 3.14.38

netlink支持用户进程和内核相互交互（两边都可以主动发起），同时还支持用户进程之间相互交互（虽然这种应用通常都采用unix-sock）

但是有一点需要注意，内核不支持接收netlink组播消息
本文将从用户进程发送一个netlink消息开始，对整个netlink消息通信原理进行展开分析

用户进程一般都通过调用sendmsg来向内核或其他进程发送netlink消息(有关sendmsg系统调用的公用部分代码解析将在另一片文章中展开)
    /* 用户进程对netlink套接字调用sendmsg()系统调用后，内核执行netlink操作的总入口函数
     * @sock    - 指向用户进程的netlink套接字，也就是发送方的
     * @msg     - 承载了发送方传递的netlink消息
     * @len     - netlink消息长度
     * @kiocb   - 这个参数在最新内核中已经去掉，这里索性不再进行分析(其实是因为还没开撸这块代码~)
     *
     * 备注： netlink套接字在创建的过程中(具体是在__netlink_create函数开头)，已经和netlink_ops(socket层netlink协议族的通用操作集合)关联,
     *        其中注册的sendmsg回调就是指向本函数
     */
    static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,struct msghdr *msg, size_t len)
    {
        // 显然，这里定义的addr指向netlink消息的目的地
        DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);    

        // netlink消息不支持传输带外数据
        if (msg->msg_flags&MSG_OOB)
            return -EOPNOTSUPP;

        // 辅助消息处理
        if (NULL == siocb->scm)
            siocb->scm = &scm;
        err = scm_send(sock, msg, siocb->scm, true);

        if (msg->msg_namelen) {
            // 如果用户进程指定了目的地址，则对其进行合法性检测，然后从中获取单播地址和组播地址
            err = -EINVAL;
            if (addr->nl_family != AF_NETLINK)
                goto out;
            dst_portid = addr->nl_pid;
            dst_group = ffs(addr->nl_groups);
            err =  -EPERM;

            // 如果有设置目的组播地址，或者目的单播地址不是发往kernel，就需要检查具体的netlink协议是否支持
            if ((dst_group || dst_portid) && !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
                goto out;
            netlink_skb_flags |= NETLINK_SKB_DST;
        
        }    
        else{
            // 如果用户进程没有指定目的地址，则使用该netlink套接字默认的(缺省都是0,可以通过connect系统调用指定)
            dst_portid = nlk->dst_portid;
            dst_group = nlk->dst_group;
        }

        // 如果该netlink套接字还没有被绑定过，首先执行动态绑定
        if (!nlk->portid){
            err = netlink_autobind(sock);
        }

        // 以下这部分只有当内核配置了CONFIG_NETLINK_MMAP选项才生效(暂不分析)
        if (netlink_tx_is_mmaped(sk) && msg->msg_iov->iov_base == NULL){
            err = netlink_mmap_sendmsg(sk, msg, dst_portid, dst_group,siocb);
        }

        // 检查需要发送的数据长度是否合法
        err = -EMSGSIZE;
        if (len > sk->sk_sndbuf - 32)
            goto out;

        // 分配skb结构空间
        err = -ENOBUFS;
        skb = netlink_alloc_large_skb(len, dst_group);

        // 初始化这个skb中的cb字段
        NETLINK_CB(skb).portid  = nlk->portid;
        NETLINK_CB(skb).dst_group = dst_group;
        NETLINK_CB(skb).creds   = siocb->scm->creds;
        NETLINK_CB(skb).flags   = netlink_skb_flags;

        // 将数据从msg_iov拷贝到skb中
        err = -EFAULT;
        memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)

        // 执行LSM模块，略过
        err = security_netlink_send(sk, skb);

        // 至此，netlink消息已经被放入新创建的sbk中，接下来，内核根据单播还是组播消息，执行了不同的发送流程
        // 发送netlink组播消息
        if (dst_group){
            atomic_inc(&skb->users);
            netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
        }

        // 发送netlink单播消息
        err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);
    }

    小结：从netlink_sendmsg函数的末尾可以看出，来自用户进程的netlink消息会以netlink_unicast单播方式或netlink_broadcast组播方式进行传递。
          所以接下来进一步对这两种传播方式进行展开分析。


    /* 以下是内核执行netlink单播消息的发送流程
     * @ssk         - 源sock结构
     * @skb         - 属于发送方的承载了netlink消息的skb
     * @portid      - 目的单播地址
     * @nonblock    - 1：非阻塞调用，2：阻塞调用
     *
     * 备注: 以下3种情况都会调用到本函数：
     *          [1]. kernel     --单播--> 用户进程
     *          [2]. 用户进程   --单播--> kernel
     *          [3]. 用户进程a  --单播--> 用户进程b
     */
    int netlink_unicast(struct sock *ssk, struct sk_buff *skb,u32 portid, int nonblock)
    {
        // 重新调整skb数据区大小
        skb = netlink_trim(skb, gfp_any());
        
        // 计算发送超时时间(如果是非阻塞调用，则返回0)
        timeo = sock_sndtimeo(ssk, nonblock);

    retry:
        // 根据源sock结构和目的单播地址，得到目的sock结构
        sk = netlink_getsockbyportid(ssk, portid);

        // 如果该目的netlink套接字属于内核，则进入第 [2] 种情况下的分支
        if (netlink_is_kernel(sk))
            return netlink_unicast_kernel(sk, skb, ssk);

        // 程序运行到这里，意味着以下属于第 [1]/[3] 种情况下的分支
        // 对于发往用户进程的单播消息都要调用BPF过滤
        if (sk_filter(sk, skb)){
            err = skb->len;
            kfree_skb(skb);
            sock_put(sk);
            return err;
        }

        // 将该skb绑定到目的用户进程netlink套接字上，如果成功，skb的所有者也从这里开始变更为目的用户进程netlink套接字
        err = netlink_attachskb(sk, skb, &timeo, ssk);
        // 如果返回值是1，意味着要重新尝试绑定操作
        if (err == 1)
            goto retry;
        if (err)
            return err;

        // 将该skb发送到目的用户进程netlink套接字
        return netlink_sendskb(sk, skb);
    }

    /* 来自用户进程的netlink消息单播发往内核netlink套接字
     * @sk  - 目的sock结构
     * @skb - 属于发送方的承载了netlink消息的skb
     * @ssk - 源sock结构
     *
     * 备注：skb的所有者在本函数中发生了变化
     */
    static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,struct sock *ssk)
    {
        // 获取目的netlink套接字，也就是内核netlink套接字
        struct netlink_sock *nlk = nlk_sk(sk);

        // 检查内核netlink套接字是否注册了netlink_rcv回调(就是各个协议在创建内核netlink套接字时通常会传入的input函数)
        if (nlk->netlink_rcv != NULL) {
            ret = skb->len;
            // 设置该skb的所有者是内核的netlink套接字
            netlink_skb_set_owner_r(skb, sk);
            // 保存该netlink消息的源sock结构
            NETLINK_CB(skb).sk = ssk;
            // netlink tap机制暂略
            netlink_deliver_tap_kernel(sk, ssk, skb);
            // 调用内核netlink套接字的协议类型相关的netlink_rcv钩子来处理收到的消息
            // 到这里，意味着发往内核的netlink消息已经被成功接收
            nlk->netlink_rcv(skb);
        } else {
            // 如果指定的内核netlink套接字没有注册netlink_rcv回调，就直接丢弃所有收到的netlink消息
            kfree_skb(skb);
        }
        sock_put(sk);
    }
    
    /* 将一个指定skb绑定到一个指定的属于用户进程的netlink套接字上
     * @sk      - 指向目的sock结构
     * @skb     - 属于发送方的承载了netlink消息的skb
     * @timeo   - 指向一个超时时间
     * @ssk     - 指向源sock结构
     */
    int netlink_attachskb(struct sock *sk, struct sk_buff *skb,long *timeo, struct sock *ssk)
    {
        // 获取目的netlink套接字，也就是目的用户进程netlink套接字
        nlk = nlk_sk(sk);

        /* 在没有内核使能CONFIG_NETLINK_MMAP配置选项时,
         * 如果目的netlink套接字上已经接收尚未处理的数据大小超过了接收缓冲区大小，或者目的netlink套接字被设置了拥挤标志，
         * 意味着该sbk不能立即被目的netlink套接字接收，需要加入等待队列
         */
        if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(NETLINK_CONGESTED, &nlk->state)) && !netlink_skb_is_mmaped(skb)){
            // 申请一个等待队列
            DECLARE_WAITQUEUE(wait, current);
            // 如果传入的超时时间为0,意味着非阻塞调用，则丢弃这条netlink消息，并返回EAGAIN
            if (!*timeo) {
                /* 如果该netlink消息对应的源sock结构不存在，或者该netlink消息来自kernel
                 * 则对目的netlink套接字设置缓冲区溢出状态
                 */
                if (!ssk || netlink_is_kernel(ssk))
                    netlink_overrun(sk);
                sock_put(sk);
                kfree_skb(skb);
                return -EAGAIN;
            }

            // 程序运行到这里意味着是阻塞调用
            // 改变当前进程状态为可中断
            __set_current_state(TASK_INTERRUPTIBLE);
            // 将目的netlink套接字加入等待队列（同时意味着进入睡眠，猜测）
            add_wait_queue(&nlk->wait, &wait);

            // 程序到这里意味着被唤醒了(猜测)
            // 如果接收条件还是不满足，则要计算剩余的超时时间
            if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(NETLINK_CONGESTED, &nlk->state)) && !sock_flag(sk, SOCK_DEAD))
                *timeo = schedule_timeout(*timeo);

            // 改变当前进程状态为运行
            __set_current_state(TASK_RUNNING);
            // 将目的netlink套接字从等待队列中删除
            remove_wait_queue(&nlk->wait, &wait);
            sock_put(sk);

            // 目测是信号相关处理，略
            if (signal_pending(current)) {
                kfree_skb(skb);
                return sock_intr_errno(*timeo);
            }

            // 返回1,意味着还将要再次调用本函数
            return 1;
        }

        // 设置该skb的所有者是目的用户进程netlink套接字，这里才是真正的绑定操作，上面都是前奏
        netlink_skb_set_owner_r(skb, sk);
    }

    /* 将指定skb发送到目的用户进程netlink套接字(显然，本函数只是个封装)
     * @sk  - 目的用户进程netlink套接字
     * @skb - 指向一个承载了netlink消息的skb
     * @返回值  - 成功返回实际发送的netlink消息长度
     *
     * 备注：该skb调用本函数前已经绑定到该用户进程netlink套接字
     */
    int netlink_sendskb(struct sock *sk, struct sk_buff *skb)
    {
        int len = __netlink_sendskb(sk, skb);
        sock_put(sk);
        return len
    }

    /* 将指定skb发送到指定用户进程netlink套接字，换句话说，实际也就是将该skb放入了该套接字的接收队列中
     * @sk  - 指向一个用户进程netlink套接字
     * @skb - 指向一个承载了netlink消息的skb
     *
     * 备注：该skb调用本函数前已经绑定到该用户进程netlink套接字
     *       之所以说组播消息不支持发往内核的根本原因就在本函数中：
     *              本函数最后通过调用sk_data_ready钩子函数来通知所在套接字接收组播消息，
     *              而内核netlink套接字实际屏蔽了这个钩子函数，也就意味着永远无法接收到组播消息
     */
    static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
    {
        // 这里可以知道，成功时的返回值就是skb中承载的netlink消息长度
        int len = skb->len;

        // 目前不知道tap系列函数的用处
        netlink_deliver_tap(skb);

        // 将skb放入该netlink套接字接收队列末尾
        skb_queue_tail(&sk->sk_receive_queue, skb);
        // 执行sk_data_ready回调通知该套接字有数据可读
        sk->sk_data_ready(sk, len);

        return len;
    }

    小结：至此，一个来自用户进程的netlink单播消息的传递流程基本分析完毕
          可以看出，流程的终点，一个是内核netlink套接字具体协议类型相关的netlink_rcv回调，另一个是目的用户进程netlink套接字的接收队列
          还可以看出，跟内核发往用户进程的netlink单播消息流程存在部分重合

    /* 发送netlink组播消息(显然这只是个封装)
     * @ssk         - 源sock结构
     * @skb         - 属于发送方的承载了netlink消息的skb
     * @portid      - 目的单播地址
     * @group       - 目的组播地址
     *
     * 备注: 以下2种情况都会调用到本函数：
     *          [1]. 用户进程   --组播--> 用户进程
     *          [2]. kernel     --组播--> 用户进程
     */
    int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid,u32 group, gfp_t allocation)
    {
        return netlink_broadcast_filtered(ssk, skb, portid, group, allocation,NULL, NULL);
    }

    /* 发送netlink组播消息
     * @ssk         - 源sock结构
     * @skb         - 属于发送方的承载了netlink消息的skb
     * @portid      - 目的单播地址
     * @group       - 目的组播地址
     * @filter      - 指向一个过滤器
     * @filter_data - 指向一个传递给过滤器的参数
     */
    int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,u32 group, gfp_t allocation,int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),void *filter_data)
    {
        // 获取源sock所在net命名空间
        struct net *net = sock_net(ssk);

        // 重新调整skb数据区大小
        skb = netlink_trim(skb, allocation);

        info.exclude_sk = ssk;
        info.net = net;
        info.portid = portid;
        info.group = group;
        info.failure = 0;
        info.delivery_failure = 0;
        info.congested = 0;
        info.delivered = 0;
        info.allocation = allocation;
        info.skb = skb;
        info.skb2 = NULL;
        info.tx_filter = filter;
        info.tx_data = filter_data;

        // 遍历该netlink套接字所在协议类型中所有阅订了组播功能的套接字，然后尝试向其发送该组播消息
        sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
            do_one_broadcast(sk, &info);

        // 至此，netlink组播消息已经发送完毕
        // 释放skb结构
        consume_skb(skb);

        // 发送失败处理
        if (info.delivery_failure){
            kfree_skb(info.skb2);
            return -ENOBUFS;
        }

        // 释放skb2结构
        consume_skb(info.skb2);

        // 发送成功处理
        if (info.delivered){
            if (info.congested && (allocation & __GFP_WAIT))
                yield();
            return 0;
        }
    }

    /* 尝试向指定用户进程netlink套接字发送组播消息
     * @sk  - 指向一个sock结构，对应一个用户进程netlink套接字
     * @p   - 指向一个netlink组播消息的管理块
     *
     * 备注：传入的netlink套接字跟组播消息属于同一种netlink协议类型，并且这个套接字开启了组播阅订，除了这些，其他信息(比如阅订了具体哪些组播)都是不确定的
     */
    static int do_one_broadcast(struct sock *sk,struct netlink_broadcast_data *p)
    {
        // 如果源sock和目的sock是同一个则直接返回
        if (p->exclude_sk == sk)
            goto out;
        // 如果目的单播地址就是该netlink套接字，或者目的组播地址超出了该netlink套接字的上限，或者该netlink套接字没有阅订这条组播消息，都直接返回
        if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups || !test_bit(p->group - 1, nlk->groups))
            goto out;
        // 如果两者不属于同一个net命名空间，则直接返回
        if (!net_eq(sock_net(sk), p->net))
            goto out;
        // 如果netlink组播消息的管理块携带了failure标志, 则对该netlink套接字设置缓冲区溢出状态
        if (p->failure){
            netlink_overrun(sk);
            goto out;
        }

        // 设置skb2，其内容来自skb
        if (p->skb2 == NULL){
            if (skb_shared(p->skb))
                p->skb2 = skb_clone(p->skb, p->allocation);
            else{
                p->skb2 = skb_get(p->skb);
                skb_orphan(p->skb2);
            }
        }

        if (p->skb2 == NULL){
            // 到这里如果skb2还是NULL，意味着上一步中clone失败
            netlink_overrun(sk);
            p->failure = 1;
            if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
                p->delivery_failure = 1;
        }
        else if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)){
            // 如果传入了发送过滤器，但是过滤不通过，释放skb2
            kfree_skb(p->skb2);
            p->skb2 = NULL;
        }
        else if (sk_filter(sk, p->skb2)){
            // 如果BPF过滤不通过，释放skb2
            kfree_skb(p->skb2);
            p->skb2 = NULL;
        }
        else if ((val = netlink_broadcast_deliver(sk, p->skb2)) < 0){
            // 如果将承载了组播消息的skb发送到该用户进程netlink套接字失败
            netlink_overrun(sk);
            if (nlk->flags & NETLINK_BROADCAST_SEND_ERROR)
                p->delivery_failure = 1;
        }
        else{
            // 发送成功最终会进入这里
            p->congested |= val;
            p->delivered = 1;
            p->skb2 = NULL;     // 这里没有释放skb2，而是在上层函数进行释放，原因是因为上层遍历时可能要反复进入本函数，所以skb2要被反复用到
        }
    }

    /* 将携带了netlink组播消息的skb发送到指定目的用户进程netlink套接字
     * @返回值      -1  :套接字接收条件不满足
     *              0   :netlink组播消息发送成功，套接字已经接收但尚未处理数据长度小于等于其接收缓冲的1/2
     *              1   :netlink组播消息发送成功，套接字已经接收但尚未处理数据长度大于其接收缓冲的1/2(这种情况似乎意味着套接字处于拥挤状态)
     *
     * 备注：到本函数这里，已经确定了传入的netlink套接字跟组播消息匹配正确；
     *       netlink组播消息不支持阻塞
     */
    static int netlink_broadcast_deliver(struct sock *sk, struct sk_buff *skb)
    {
        // 判断该netlink套接字是否满足接收条件
        if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf && !test_bit(NETLINK_CONGESTED, &nlk->state)){
            // 如果满足接收条件，则设置skb的所有者是该netlink套接字
            netlink_skb_set_owner_r(skb, sk);
            // 将skb发送到该netlink套接字，实际也就是将该skb放入了该套接字的接收队列中
            __netlink_sendskb(sk, skb);

            // 这里最后判断该netlink套接字的已经接收尚未处理数据长度是否大于其接收缓冲的1/2
            return atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1);
        }

        // 程序运行到这里意味着接收条件不满足
        return -1;
    }

    小结：至此，一个来自用户进程的netlink组播消息的传递流程基本分析完毕
          可以看出，流程的终点只有一个，就是目的用户进程netlink套接字的接收队列
          还可以看出，跟内核发往用户进程的netlink组播消息流程存在重合

以上就是用户进程向内核或其他进程发送netlink消息的完整流程，显然，其中重合了大量由内核发送netlink消息到用户进程的流程。
所以接下来内核发送netlink消息到用户进程的分析中，重合部分的代码将不再展开。
    /* 内核提供了API函数nlmsg_unicast供各个netlink协议调用，来向用户进程发送netlink单播消息(显然，这只是个封装)
     * @sk  - 指向源sock结构，也就是内核netlink套接字
     * @skb - 指向一个承载了单播netlink消息的skb
     * @portid  - 目的单播地址
     *
     * 备注：可以看出，内核只会以非阻塞的形式往用户进程发送netlink单播消息
     */
    static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
    {
        netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
    }

    /* 内核提供了API函数nlmsg_multicast供各个netlink协议调用，来向用户进程发送netlink组播消息(显然，这只是个封装)
     * 指向源sock结构
     * 指向一个承载了组播netlink消息的skb
     * 目的单播地址
     * 目的组播地址
     */
    static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,u32 portid, unsigned int group, gfp_t flags)
    {
        NETLINK_CB(skb).dst_group = group;
        netlink_broadcast(sk, skb, portid, group, flags);
    }

    小结：至此，内核发送netlink消息到用户进程的接口分析完毕
          内核不管是发送单播还是组播消息，流程的终点都只有一个，就是目的用户进程netlink套接字的接收队列

本文最后要分析的就是netlink消息接收流程了，由于发往内核的netlink消息在调用协议类型相关的netlink_rcv钩子时就已经意味着接收完成了，也就没有展开分析的必要。
所以接下来实际上就是对用户进程调用recvmsg接收来自内核或者其他进程的netlink消息流程展开分析(有关recvmsg系统调用的公用部分代码解析将在另一片文章中展开)
    /* 用户进程对netlink套接字调用recvmsg()系统调用后，内核执行netlink操作的总入口函数
     *  @sock    - 指向用户进程的netlink套接字，也就是接收方的
     *  @msg     - 用于存放接收到的netlink消息
     *  @len     - 用户空间支持的netlink消息接收长度上限
     *  @flags   - 跟本次接收操作有关的标志位集合(主要来源于用户空间)
     */
    static int netlink_recvmsg(struct kiocb *kiocb, struct socket *sock,struct msghdr *msg, size_t len,int flags)
    {
        int noblock = flags&MSG_DONTWAIT;

        // netlink消息不支持接收带外数据
        if (flags&MSG_OOB)
            return -EOPNOTSUPP;

        // 从套接字的接收队列中接收数据
        skb = skb_recv_datagram(sk, flags, noblock, &err);
        if (skb == NULL)
            goto out;
        
        // 程序运行到这里意味着已经获取到一个skb
        data_skb = skb;

        // 如果收到的skb中承载的netlink消息长度大于用户空间接收缓存的最大长度，则设置MSG_TRUNC标志，并将实际接收长度改为接收缓存的长度
        copied = data_skb->len;
        if (len < copied){
            msg->msg_flags |= MSG_TRUNC;
            copied = len;
        }

        // 计算transport layer相对缓冲区头部的偏移量(目前不知道干嘛用)
        skb_reset_transport_header(data_skb);

        // 将skb中的数据拷贝到iovec结构的数据缓冲区
        err = skb_copy_datagram_iovec(data_skb, 0, msg->msg_iov, copied);
    
        // 填充返回给用户进程的地址信息
        if (msg->msg_name){
            DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
            addr->nl_family = AF_NETLINK;
            addr->nl_pad    = 0;
            addr->nl_pid    = NETLINK_CB(skb).portid;
            addr->nl_groups = netlink_group_mask(NETLINK_CB(skb).dst_group);
            msg->msg_namelen = sizeof(*addr);
        }

        // 处理netlink辅助消息
        if (nlk->flags & NETLINK_RECV_PKTINFO)
            netlink_cmsg_recv_pktinfo(msg, skb);
        if (NULL == siocb->scm){
            memset(&scm, 0, sizeof(scm));
            siocb->scm = &scm;
        }
        siocb->scm->creds = *NETLINK_CREDS(skb);

        // 如果用户进程recvmsg传入了MSG_TRUNC标志，这里重新将返回的长度值改为skb实际收到的数据长度
        if (flags & MSG_TRUNC)
            copied = data_skb->len;

        // 释放承载了该netlink消息的skb
        skb_free_datagram(sk, skb);

        // 如果有需要还要执行dump操作(执行dump操作的通常是内核，用户进程执行dump操作需要进行确认)
        if (nlk->cb_running && atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf / 2)
            ret = netlink_dump(sk);

        scm_recv(sock, msg, siocb->scm, flags);

out:
        // 正常情况下，程序运行到这里意味着一个承载了netlink消息的skb已经处理完毕
        // 最后在条件合适的情况下将会唤醒该netlink套接字的等待队列中的用户进程
        netlink_rcv_wake(sk);
        return err ? : copied;
    }


至此，netlink通信原理全部分析完毕，当然本文只是针对通用的通信流程进行了展开。
具体协议类型的netlink还拥有自己私有的消息处理方式，针对几个重要的具体协议类型(NETLINK_ROUTE、NETLINK_GENERIC)，将会另写文章分别进行分析