Linux Netlink通信机制详解

 前面有一篇文章其实已经介绍过Netlink方面的知识,还有一个内核和用户空间之间的一个交互例子,这篇文章主要是更细节和基础的知识介绍!

Netlink 是一种特殊的 socket,它是 Linux 所特有的,由于传送的消息是暂存在socket接收缓存中,并不被接收者立即处理,所以netlink是一种异步通信机制。 系统调用和ioctl 则是同步通信机制。

用户空间进程可以通过标准socket API来实现消息的发送、接收,在Linux中,有很多用户空间和内核空间的交互都是通过Netlink机制完成的,在Linux3.0的内核版本中定义了下面的21个用于Netlink通信的宏,其中默认的最大值为32.我这里重点关注的是IPv6路由部分的通信过程。

  在include/linux/`netlink.h文件中定义了下面的用于通信的宏!

  1. #define NETLINK_ROUTE        0    /* Routing/device hook                */
  2. #define NETLINK_UNUSED        1    /* Unused number                */
  3. #define NETLINK_USERSOCK    2    /* Reserved for user mode socket protocols     */
  4. #define NETLINK_FIREWALL    3    /* Firewalling hook                */
  5. #define NETLINK_INET_DIAG    4    /* INET socket monitoring            */
  6. #define NETLINK_NFLOG        5    /* netfilter/iptables ULOG */
  7. #define NETLINK_XFRM        6    /* ipsec */
  8. #define NETLINK_SELINUX        7    /* SELinux event notifications */
  9. #define NETLINK_ISCSI        8    /* Open-iSCSI */
  10. #define NETLINK_AUDIT        9    /* auditing */
  11. #define NETLINK_FIB_LOOKUP    10    
  12. #define NETLINK_CONNECTOR    11
  13. #define NETLINK_NETFILTER    12    /* netfilter subsystem */
  14. #define NETLINK_IP6_FW        13
  15. #define NETLINK_DNRTMSG        14    /* DECnet routing messages */
  16. #define NETLINK_KOBJECT_UEVENT    15    /* Kernel messages to userspace */
  17. #define NETLINK_GENERIC        16
  18. /* leave room for NETLINK_DM (DM Events) */
  19. #define NETLINK_SCSITRANSPORT    18    /* SCSI Transports */
  20. #define NETLINK_ECRYPTFS    19
  21. #define NETLINK_RDMA        20
  22.  
  23. #define MAX_LINKS 32

   用户态可以使用标准的socket APIs, socket(), bind(), sendmsg(), recvmsg() 和 close() 等函数就能很容易地使用 netlink socket,我们在用户空间可以直接通过socket函数来使用Netlink通信,例如可以通过下面的方式:

  1. sock = socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

说明:第一个参数必须是 AF_NETLINK 或 PF_NETLINK,在 Linux 中,它们俩实际为一个东西,它表示要使用netlink,第二个参数必须是SOCK_RAW或SOCK_DGRAM, 第三个参数指定netlink协议类型,可以是自己在netlink.h中定义的,也可以是内核中已经定义好的。上面的例子使用主要是路由的Netlink协议。也可以是上面21中协议类型的其中之一。

NETLINK_GENERIC是一个通用的协议类型,它是专门为用户使用的,因此,用户可以直接使用它,而不必再添加新的协议类型。

对于每一个netlink协议类型,可以使用多播的概念,最多可以有 32个多播组,每一个多播组用一个位表示,netlink 的多播特性使得发送消息给同一个组仅需要一次系统调用,因而对于需要多播消息的应用而言,大大地降低了系统调用的次数。

下面介绍一下主要的数据结构:

  1. struct sockaddr_nl {
  2.     sa_family_t    nl_family;    /* AF_NETLINK    */
  3.     unsigned short    nl_pad;        /* zero        */
  4.     __u32        nl_pid;        /* port ID    */
  5.    __u32        nl_groups;    /* multicast groups mask */
  6. };

说明:(1)        sa_family_t      nl_family;         

      一般为AF_NETLINK,

(2)       unsigned short         nl_pad;

 字段 nl_pad 当前没有使用,因此要总是设置为 0,

(3)__u32              nl_pid;              

 绑定时用于指定绑定者的进程号,发送消息时用于指定接收进程号,如果希望内核处理多播消息,就把该字段设置为 0,否则设置为处理消息的进程 ID。传递给 bind 函数的地址的 nl_pid 字段应当设置为本进程的进程 ID,这相当于 netlink socket 的本地地址。但是,对于一个netlink socket 的情况,字段nl_pid 则可以设置为其它的值,如:

pthread_self() << 16 | getpid();

因此字段 nl_pid 实际上未必是进程 ID,它只是用于区分不同的接收者或发送者的一个标识,用户可以根据自己需要设置该字段。

(4)   __u32                 nl_groups;

    绑定时用于指定绑定者所要加入的多播组,这样绑定者就可以接收多播消息,发送 消息时可以用于指定多播组,这样就可以将消息发给多个接收者。这里nl_groups 为32位的无符号整形,所以可以指定32个多播组,每个进程可以加入多个多播组, 因为多播组是通过“或”操作,如果设置为 0,表示调用者不加入任何多播组。这里就是Netlink多播的概念!和通信中的多播概念有点类似。 

Bind的调用方式如下!

  1. struct sockaddr_nl snl;
  2. memset (&snl, 0, sizeof snl);
  3.   snl.nl_family = AF_NETLINK;
  4.   snl.nl_groups = groups;
  5.   ret = bind (sock, (struct sockaddr *) &snl, sizeof snl);

   其中sock为前面的 socket 调用返回的文件描述符,参数snl为 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 的定义如下: 

  1. struct msghdr {
  2.     void    *    msg_name;    /* Socket name            */
  3.     int        msg_namelen;    /* Length of name        */
  4.     struct iovec *    msg_iov;    /* Data blocks            */
  5.     __kernel_size_t    msg_iovlen;    /* Number of blocks        */
  6.     void     *    msg_control;    /* Per protocol magic (eg BSD file descriptor passing) */
  7.     __kernel_size_t    msg_controllen;    /* Length of cmsg list */
  8.     unsigned    msg_flags;
  9. };

使用方法如下:

  1. struct msghdr msg;
  2. memset(&msg, 0, sizeof(msg));
  3. msg.msg_name = (void *)&(snl);
  4. msg.msg_namelen = sizeof(snl);

struct nlmsghdr 为 netlink socket 自己的消息头,因此它也被称为netlink 控制块。应用层在向内核发送 netlink 消息时必须提供该控制头。

消息头。

  1. struct nlmsghdr
  2. {
  3.     __u32        nlmsg_len;    /* Length of message including header */
  4.     __u16        nlmsg_type;    /* Message content */
  5.     __u16        nlmsg_flags;    /* Additional flags */
  6.     __u32        nlmsg_seq;    /* Sequence number */
  7.     __u32        nlmsg_pid;    /* Sending process PID */
  8. };

字段 nlmsg_len 指定消息的总长度,包括紧跟该结构的数据部分长度以及该结构的大小,字段nlmsg_type 用于应用内部定义消息的类型,它对netlink 内核实现是透明的,因此大部分情况下设置为 0,字段 nlmsg_seq 和 nlmsg_pid 用于应用追踪消息,前者表示顺序号,后者为消息来源进程 ID。字段nlmsg_flags 用于设置消息标志,可用的标志包括下面的宏定义:kernel/include/linux/netlink.c

  1. /* Flags values */
  2.  
  3. #define NLM_F_REQUEST        1    /* It is request message.     */
  4. #define NLM_F_MULTI        2    /* Multipart message, terminated by NLMSG_DONE */
  5. #define NLM_F_ACK        4    /* Reply with ack, with zero or error code */
  6. #define NLM_F_ECHO        8    /* Echo this request         */
  7.  
  8. /* Modifiers to GET request */
  9. #define NLM_F_ROOT    0x100    /* specify tree    root    */
  10. #define NLM_F_MATCH    0x200    /* return all matching    */
  11. #define NLM_F_ATOMIC    0x400    /* atomic GET        */
  12. #define NLM_F_DUMP    (NLM_F_ROOT|NLM_F_MATCH)
  13.  
  14. /* Modifiers to NEW request */
  15. #define NLM_F_REPLACE    0x100    /* Override existing        */
  16. #define NLM_F_EXCL    0x200    /* Do not touch, if it exists    */
  17. #define NLM_F_CREATE    0x400    /* Create, if it does not exist    */
  18. #define NLM_F_APPEND    0x800    /* Add to end of list        */

标志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 需要它进行一些设置),

下面是在调用sendmsg函数之前的各个结构体的赋值操作:

  1. struct nlmsghdr *n 
  2.   struct iovec iov = { (void*) n, n->nlmsg_len };
  3.   struct msghdr msg = {(void*) &snl, sizeof snl, &iov, 1, NULL, 0, 0};

其中snl为  struct sockaddr_nl snl;在结构体struct msghdr中包含有struct iovec结构,其实就是我们要传输的数据块,它为一个指针,定义了数据块的基址和长度。

 

  1. struct iovec
  2. {
  3.     void __user *iov_base;    /* BSD uses caddr_t (1003.1g requires void *) */
  4.     __kernel_size_t iov_len; /* Must be size_t (1003.1g) */
  5. };

上面的数据结构全部初始化以后就可以调用sendmsg函数进行发送操作了。

  1. status = sendmsg (sock, &msg, 0);

其中sock就是我们创建的sock套接字,msg就是上面结构体struct msghdr的实例。如果我们需要返回一个ACK消息,可以对flags标志进行设置如下:

  1. /* Request an acknowledgement by setting NLM_F_ACK */
  2.   n->nlmsg_flags |= NLM_F_ACK;

  使用下面的函数进行接收处理时,status;为返回的状态,这里可能的结果为:

  1. #define NLMSG_NOOP        0x1    /* Nothing.        */
  2. #define NLMSG_ERROR        0x2    /* Error        */
  3. #define NLMSG_DONE        0x3    /* End of a dump    */
  4. #define NLMSG_OVERRUN        0x4    /* Data lost    
  5. int status;
  6. char buf[4096];
  7.       struct iovec iov = { buf, sizeof buf };
  8.       struct sockaddr_nl snl;
  9.       struct msghdr msg = { (void*)&snl, sizeof snl, &iov, 1, NULL, 0, 0};
  10.       struct nlmsghdr *h;
  11.       status = recvmsg (sock, &msg, 0);

在linux/netlink.h中定义了一些方便对消息进行处理的宏,这些宏包括:

#define NLMSG_ALIGNTO       4

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

/*宏NLMSG_ALIGN(len)用于得到不小于len且字节对齐的最小数值*/

#define NLMSG_HDRLEN         ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))

#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(NLMSG_HDRLEN))

/*宏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的长度*/

在/kernel/net/netlink/af_netlink.c文件中定义了netlink套接字的结构体,

  1. struct netlink_sock {
  2.     /* struct sock has to be the first member of netlink_sock */
  3.     struct sock        sk;
  4.     u32            pid; //内核自己的pid,=0
  5.     u32            dst_pid;
  6.     u32            dst_group;//目的组
  7.     u32            flags;
  8.     u32            subscriptions;
  9.     u32            ngroups;// 组数量
  10.     unsigned long        *groups; //组号
  11.     unsigned long        state;
  12.     wait_queue_head_t    wait;// 进程在接收数据包时等待队列
  13.     struct netlink_callback    *cb;
  14.     spinlock_t        cb_lock;
  15.     void            (*data_ready)(struct sock *sk, int bytes); ///内核态接收到用户态信息后的处理函数
  16.     struct module        *module;
  17. };

在af_netlink.c文件中我们可以看到netlink协议的注册

  1. static struct proto netlink_proto = {
  2.     .name     = "NETLINK",
  3.     .owner     = THIS_MODULE,
  4.     .obj_size = sizeof(struct netlink_sock),
  5. };

在static int __init netlink_proto_init(void)函数中会调用注册协议的函数,对netlink协议进行注册,其中,netlink_proto就是上面的struct proto netlink_proto协议。

  1. int err = proto_register(&netlink_proto, 0);

在内核中接收的数据和存储发送的数据都是放在了skb_buff的结构体中

  1. struct netlink_skb_parms
  2. {
  3.     struct ucred        creds;        /* Skb credentials    */
  4.     __u32            pid;
  5.     __u32            dst_pid;
  6.     __u32            dst_group;
  7.     kernel_cap_t        eff_cap;
  8.     __u32            loginuid;    /* Login (audit) uid */
  9. };

使用下面的宏获取skb_bff中的数据部分

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

  这里我以路由中的netlink为例,看一下内核中的处理流程是怎么样的!在/kernel/net/core/rtnetlink.c文件中,有一个接收从用户空间过来的Netlink消息的函数。

  1. static void rtnetlink_rcv(struct sock *sk, int len)
  2. {
  3.     unsigned int qlen = 0;
  4.  
  5.     do {
  6.         rtnl_lock();
  7.         netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg);
  8.         up(&rtnl_sem);
  9.  
  10.         netdev_run_todo();
  11.     } while (qlen);
  12. }

上面的内核函数就是用来接收用户路由方面Netlink消息的,当我们使用route命令添加一条路由时,就会调用该函数接收。该函数是再netlink的初始化是注册的。同样在rtnetlink.c文件中。

  1. void __init rtnetlink_init(void)
  2. {
  3.     int i;
  4.  
  5.     rtattr_max = 0;
  6.     for (i = 0; i < ARRAY_SIZE(rta_max); i++)
  7.         if (rta_max[i] > rtattr_max)
  8.             rtattr_max = rta_max[i];
  9.     rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL);
  10.     if (!rta_buf)
  11.         panic("rtnetlink_init: cannot allocate rta_buf\n");
  12.  
  13.     rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv,
  14.      THIS_MODULE);//在创建内核的netlink时,注册了路由netlink的接收函数,rtnetlink_rcv.
  15.     if (rtnl == NULL)
  16.         panic("rtnetlink_init: cannot initialize rtnetlink\n");
  17.     netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV);
  18.     register_netdevice_notifier(&rtnetlink_dev_notifier);
  19.     rtnetlink_links[PF_UNSPEC] = link_rtnetlink_table;
  20.     rtnetlink_links[PF_PACKET] = link_rtnetlink_table;
  21. }

在netlink_kernel_create函数中,可以看到内核接收用户空间传过来的消息的接收函数,

  1. struct sock *
  2. netlink_kernel_create(int unit, unsigned int groups,
  3.                       void (*input)(struct sock *sk, int len),
  4.                       struct module *module)
  5. {
  6.     struct socket *sock;
  7.     struct sock *sk;
  8.     struct netlink_sock *nlk;
  9.  
  10.     if (!nl_table)
  11.         return NULL;
  12.  
  13.     if (unit<0 || unit>=MAX_LINKS)
  14.         return NULL;
  15.  
  16.     if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
  17.         return NULL;
  18.  
  19.     if (__netlink_create(sock, unit) < 0)
  20.         goto out_sock_release;
  21.  
  22.     sk = sock->sk;
  23.     sk->sk_data_ready = netlink_data_ready;
  24.     if (input)
  25.         nlk_sk(sk)->data_ready = input;//设置内核接收Netlink消息的函数,这里就是前面的rtnetlink_rcv函数
  26.  
  27.     if (netlink_insert(sk, 0))
  28.         goto out_sock_release;
  29.  
  30.     nlk = nlk_sk(sk); //取得sock嵌入的netlink_sock结构体
  31.     nlk->flags |= NETLINK_KERNEL_SOCKET;
  32.  
  33.     netlink_table_grab();
  34.     nl_table[unit].groups = groups < 32 ? 32 : groups;
  35.     nl_table[unit].module = module;
  36.     nl_table[unit].registered = 1;// 更新netlink_table结构体信息,每中协议对应一个netlink_
  37. table结构
  38.     netlink_table_ungrab();
  39.  
  40.     return sk;
  41.  
  42. out_sock_release:
  43.     sock_release(sock);
  44.     return NULL;
  45. }

   到此,内核创建netlink到接收用户空间发送过来消息整个流程就清晰了。那当我们添加一条新路由时,在接收函数rtnetlink_rcv中的循环中,会从一个队列中调用实际的接收处理函数,这里为rtnetlink_rcv_msg函数。

  1. /**
  2.  * nelink_run_queue - Process netlink receive queue.
  3.  * @sk: Netlink socket containing the queue
  4.  * @qlen: Place to store queue length upon entry
  5.  * @cb: Callback function invoked for each netlink message found
  6.  *
  7.  * Processes as much as there was in the queue upon entry and invokes
  8.  * a callback function for each netlink message found. The callback
  9.  * function may refuse a message by returning a negative error code
  10.  * but setting the error pointer to 0 in which case this function
  11.  * returns with a qlen != 0.
  12.  *
  13.  * qlen must be initialized to 0 before the initial entry, afterwards
  14.  * the function may be called repeatedly until qlen reaches 0.
  15.  */
  16. void netlink_run_queue(struct sock *sk, unsigned int *qlen,
  17.          int (*cb)(struct sk_buff *, struct nlmsghdr *, int *))
  18. {
  19.     struct sk_buff *skb;
  20.  
  21.     if (!*qlen || *qlen > skb_queue_len(&sk->sk_receive_queue))
  22.         *qlen = skb_queue_len(&sk->sk_receive_queue);
  23.  
  24.     for (; *qlen; (*qlen)--) {
  25.         skb = skb_dequeue(&sk->sk_receive_queue);
  26.         if (netlink_rcv_skb(skb, cb)) {
  27.             if (skb->len)
  28.                 skb_queue_head(&sk->sk_receive_queue, skb);
  29.             else {
  30.                 kfree_skb(skb);
  31.                 (*qlen)--;
  32.             }
  33.             break;
  34.         }
  35.  
  36.         kfree_skb(skb);
  37.     }
  38. }

  下面是rtnetlink_rcv_msg()函数的实现,对netlink消息进行相应的处理。其中有一个数据结构

  struct rtnetlink_link *link; 其定义如下:是两个不同的处理函数

  1. struct rtnetlink_link
  2. {
  3.     int (*doit)(struct sk_buff *, struct nlmsghdr*, void *attr);
  4.     int (*dumpit)(struct sk_buff *, struct netlink_callback *cb);
  5. };
  6. /* Process one rtnetlink message. */
  7.  
  8. static __inline__ int
  9. rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp)
  10. {
  11.     struct rtnetlink_link *link;
  12.     struct rtnetlink_link *link_tab;
  13.     int sz_idx, kind;
  14.     int min_len;
  15.     int family;
  16.     int type;
  17.     int err;
  18.  
  19.     /* Only requests are handled by kernel now */
  20.     if (!(nlh->nlmsg_flags&NLM_F_REQUEST))
  21.         return 0;
  22.     type = nlh->nlmsg_type;
  23.     /* A control message: ignore them */
  24.     if (type < RTM_BASE)
  25.         return 0;
  26.     /* Unknown message: reply with EINVAL */
  27.     if (type > RTM_MAX)
  28.         goto err_inval;
  29.     type -= RTM_BASE;
  30.     /* All the messages must have at least 1 byte length */
  31.     if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg)))
  32.         return 0;
  33.     family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family;
  34.     if (family >= NPROTO) {
  35.         *errp = -EAFNOSUPPORT;
  36.         return -1;
  37.     }
  38.  
  39.     link_tab = rtnetlink_links[family];//根据用户空间传过来的不同德family类型,调用不同的处理函数,这里以路由为例的话为AF_ROUTE或者AF_NETLINK
  40.     if (link_tab == NULL)
  41.         link_tab = rtnetlink_links[PF_UNSPEC];
  42.     link = &link_tab[type]; //根据不同的type调用不同的处理函数。这里的type为RTM_NEWROUTE
  43.  
  44.     sz_idx = type>>2;
  45.     kind = type&3;
  46.  
  47.     if (kind != 2 && security_netlink_recv(skb)) {
  48.         *errp = -EPERM;
  49.         return -1;
  50.     }
  51.  
  52.     if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
  53.         if (link->dumpit == NULL)
  54.             link = &(rtnetlink_links[PF_UNSPEC][type]);
  55.  
  56.         if (link->dumpit == NULL)
  57.             goto err_inval;
  58.  
  59.         if ((*errp = netlink_dump_start(rtnl, skb, nlh,
  60.                         link->dumpit, NULL)) != 0) {
  61.             return -1;
  62.         }
  63.  
  64.         netlink_queue_skip(nlh, skb);
  65.         return -1;
  66.     }
  67.  
  68.     memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *)));
  69.  
  70.     min_len = rtm_min[sz_idx];
  71.     if (nlh->nlmsg_len < min_len)
  72.         goto err_inval;
  73.  
  74.     if (nlh->nlmsg_len > min_len) {
  75.         int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len);
  76.         struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len);
  77.  
  78.         while (RTA_OK(attr, attrlen)) {
  79.             unsigned flavor = attr->rta_type;
  80.             if (flavor) {
  81.                 if (flavor > rta_max[sz_idx])
  82.                     goto err_inval;
  83.                 rta_buf[flavor-1] = attr;
  84.             }
  85.             attr = RTA_NEXT(attr, attrlen);
  86.         }
  87.     }
  88.  
  89.     if (link->doit == NULL)
  90.         link = &(rtnetlink_links[PF_UNSPEC][type]);
  91.     if (link->doit == NULL)
  92.         goto err_inval;
  93.     err = link->doit(skb, nlh, (void *)&rta_buf[0]);//此处调用RTM_NEWROUTE,对应的route处理函数,也就是下面的inet6_rtm_newroute函数。
  94.  
  95.     *errp = err;
  96.     return err;
  97.  
  98. err_inval:
  99.     *errp = -EINVAL;
  100.     return -1;
  101. }
  102. int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
  103. {
  104.     struct rtmsg *r = NLMSG_DATA(nlh);
  105.     struct in6_rtmsg rtmsg;
  106.  
  107.     if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
  108.         return -EINVAL;
  109.     return ip6_route_add(&rtmsg, nlh, arg, &NETLINK_CB(skb));
  110. }

inet6_rtm_newroute函数通过下面的数组进行了相应的注册处理,所以上面的link->doit(skb, nlh, (void *)&rta_buf[0])就是根据下面的这个调用的。

  1. static struct rtnetlink_link inet6_rtnetlink_table[RTM_NR_MSGTYPES] = {
  2.     [RTM_GETLINK - RTM_BASE] = { .dumpit    = inet6_dump_ifinfo, },
  3.     [RTM_NEWADDR - RTM_BASE] = { .doit    = inet6_rtm_newaddr, },
  4.     [RTM_DELADDR - RTM_BASE] = { .doit    = inet6_rtm_deladdr, },
  5.     [RTM_GETADDR - RTM_BASE] = { .dumpit    = inet6_dump_ifaddr, },
  6.     [RTM_GETMULTICAST - RTM_BASE] = { .dumpit = inet6_dump_ifmcaddr, },
  7.     [RTM_GETANYCAST - RTM_BASE] = { .dumpit    = inet6_dump_ifacaddr, },
  8.     [RTM_NEWROUTE - RTM_BASE] = { .doit    = inet6_rtm_newroute, },
  9.     [RTM_DELROUTE - RTM_BASE] = { .doit    = inet6_rtm_delroute, },
  10.     [RTM_GETROUTE - RTM_BASE] = { .doit    = inet6_rtm_getroute,
  11.                  .dumpit    = inet6_dump_fib, },
  12. };

相关的结构体:

内核中所有的netlink套接字存储在一个全局的哈新表中,该结构定义如下

static struct netlink_table *nl_table;其中每个协议对应一个哈希表,所有的同一种协议的数

据报散列在同哈希表中

下面为一种协议所连接的哈希表结构:

struct netlink_table {

         struct nl_pid_hash hash; // 根据pid进行HASH的netlink sock链表, 相当于客户端链表

         struct hlist_head mc_list; // 多播的sock链表

         unsigned int nl_nonroot; // 监听者标志

         unsigned int groups; // 每个netlink的协议类型可以定义多个组, 8的倍数,最小是32

         struct module *module;

         int registered;

};最大可有MAX_LINKS(32)个表,处理不同协议类型的netlink套接口, 注意由于是自身的通信, 本机

同时作为服务器和客户端, 服务端需要一个套接口对应, 每个客户端也要有一个套接口对应, 多个客户端的套接口形成一个链表.

  1. struct hlist_head *table; // 链表节点,每个桶中协议的sock连入其中,根据哈希值可得确定
  2. 的sock
  3.     unsigned long rehash_time; // 重新计算HASH的时间间隔
  4.  
  5.     unsigned int mask;
  6.     unsigned int shift;
  7.  
  8.     unsigned int entries; // 链表节点数
  9.     unsigned int max_shift; // 最大幂值
  10.     u32 rnd; // 随机数
  11. };

在kernel/include/linux/Net.h中

  1. struct proto_ops {
  2.     int        family;
  3.     struct module    *owner;
  4.     int        (*release) (struct socket *sock);
  5.     int        (*bind)     (struct socket *sock,
  6.                  struct sockaddr *myaddr,
  7.                  int sockaddr_len);
  8.     int        (*connect) (struct socket *sock,
  9.                  struct sockaddr *vaddr,
  10.                  int sockaddr_len, int flags);
  11.     int        (*socketpair)(struct socket *sock1,
  12.                  struct socket *sock2);
  13.     int        (*accept) (struct socket *sock,
  14.                  struct socket *newsock, int flags);
  15.     int        (*getname) (struct socket *sock,
  16.                  struct sockaddr *addr,
  17.                  int *sockaddr_len, int peer);
  18.     unsigned int    (*poll)     (struct file *file, struct socket *sock,
  19.                  struct poll_table_struct *wait);
  20.     int        (*ioctl) (struct socket *sock, unsigned int cmd,
  21.                  unsigned long arg);
  22.     int        (*listen) (struct socket *sock, int len);
  23.     int        (*shutdown) (struct socket *sock, int flags);
  24.     int        (*setsockopt)(struct socket *sock, int level,
  25.                  int optname, char __user *optval, int optlen);
  26.     int        (*getsockopt)(struct socket *sock, int level,
  27.                  int optname, char __user *optval, int __user *optlen);
  28.     int        (*sendmsg) (struct kiocb *iocb, struct socket *sock,//netlink套接字实际的发送与接收函数
  29.                  struct msghdr *m, size_t total_len);
  30.     int        (*recvmsg) (struct kiocb *iocb, struct socket *sock,
  31.                  struct msghdr *m, size_t total_len,
  32.                  int flags);
  33.     int        (*mmap)     (struct file *file, struct socket *sock,
  34.                  struct vm_area_struct * vma);
  35.     ssize_t        (*sendpage) (struct socket *sock, struct page *page,
  36.                  int offset, size_t size, int flags);
  37. };

下面我们看看,当我们使用route命令添加一个新的路由是,这个函数的调用顺序是怎么样的。下面是主要的函数;

Dput()

sys_sendmsg()//内核的接受函数

new_inode()

netlink_sendmsg//内核态接收用户态发送的数据

rtnetlink_rcv()

netlink_run_queue()

rtnetlink_rcv_msg()

inet6_rtm_newroute()

在kernel/net/netlink/af_netlink.c文件中,内核态接收用户态发送的数据,在netlink_sendskb函数中调用sock的队列,执行相应的netlink接收函数

  1. static int netlink_sendmsg(struct kiocb *kiocb, struct socket *sock,
  2.              struct msghdr *msg, size_t len)
  3. {
  4.     struct sock_iocb *siocb = kiocb_to_siocb(kiocb);
  5.     struct sock *sk = sock->sk;
  6.     struct netlink_sock *nlk = nlk_sk(sk);
  7.     struct sockaddr_nl *addr=msg->msg_name;
  8.     u32 dst_pid;
  9.     u32 dst_group;
  10.     struct sk_buff *skb;
  11.     int err;
  12.     struct scm_cookie scm;
  13.  
  14.     if (msg->msg_flags&MSG_OOB)
  15.         return -EOPNOTSUPP;
  16.  
  17.     if (NULL == siocb->scm)
  18.         siocb->scm = &scm;
  19.     err = scm_send(sock, msg, siocb->scm);
  20.     if (err < 0)
  21.         return err;
  22.  
  23.     if (msg->msg_namelen) {
  24.         if (addr->nl_family != AF_NETLINK)
  25.             return -EINVAL;
  26.         dst_pid = addr->nl_pid;
  27.         dst_group = ffs(addr->nl_groups);
  28.         if (dst_group && !netlink_capable(sock, NL_NONROOT_SEND))
  29.             return -EPERM;
  30.     } else {
  31.         dst_pid = nlk->dst_pid;
  32.         dst_group = nlk->dst_group;
  33.     }
  34.  
  35.     if (!nlk->pid) {
  36.         err = netlink_autobind(sock);
  37.         if (err)
  38.             goto out;
  39.     }
  40.  
  41.     err = -EMSGSIZE;
  42.     if (len > sk->sk_sndbuf - 32)
  43.         goto out;
  44.     err = -ENOBUFS;
  45.     skb = alloc_skb(len, GFP_KERNEL);// 分配一个sk_buff结构,将msghdr结构转化为sk_buff结构
  46.     if (skb==NULL)
  47.         goto out;
  48.  
  49.     NETLINK_CB(skb).pid    = nlk->pid;//填写本地的pid信息
  50.     NETLINK_CB(skb).dst_pid = dst_pid;
  51.     NETLINK_CB(skb).dst_group = dst_group;
  52.     NETLINK_CB(skb).loginuid = audit_get_loginuid(current->audit_context);
  53.     memcpy(NETLINK_CREDS(skb), &siocb->scm->creds, sizeof(struct ucred));
  54.  
  55.     /* What can I do? Netlink is asynchronous, so that
  56.      we will have to save current capabilities to
  57.      check them, when this message will be delivered
  58.      to corresponding kernel module. --ANK (980802)
  59.      */
  60.  
  61.     err = -EFAULT;
  62. //数据拷贝进sk_buff中
  63.     if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len)) {
  64.         kfree_skb(skb);
  65.         goto out;
  66.     }
  67.  
  68.     err = security_netlink_send(sk, skb);
  69.     if (err) {
  70.         kfree_skb(skb);
  71.         goto out;
  72.     }
  73.  
  74.     if (dst_group) {
  75.         atomic_inc(&skb->users);
  76.         netlink_broadcast(sk, skb, dst_pid, dst_group, GFP_KERNEL);
  77.     }
  78.     err = netlink_unicast(sk, skb, dst_pid, msg->msg_flags&MSG_DONTWAIT);
  79.  
  80. out:
  81.     return err;
  82. }

你可能感兴趣的:(Linux__IPC)