LINUX netlink机制

 

　　用户空间的程序与设备通信的方法，主要有以下几种方式：

　　1　通过ioperm获取操作IO端口的权限，然后用inb/inw/ inl/ outb/outw/outl等函数，避开设备驱动程序，直接去操作IO端口。（没有用过）
　　2　用ioctl函数去操作/dev目录下对应的设备，这是设备驱动程序提供的接口。像键盘、鼠标和触摸屏等输入设备一般都是这样做的。
　　3　用write/read/mmap去操作/dev目录下对应的设备，这也是设备驱动程序提供的接口。像framebuffer等都是这样做的。

　　4　Netlink

　　Netlink 是一种特殊的 socket，它是 Linux 所特有的，目前在最新的 Linux 内核（2.6.14）中使用netlink 进行应用与内核通信的应用很多，包括：路由 daemon（NETLINK_ROUTE），1-wire 子系统（NETLINK_W1），用户态 socket 协议（NETLINK_USERSOCK），防火墙（NETLINK_FIREWALL），socket 监视（NETLINK_INET_DIAG），netfilter 日志（NETLINK_NFLOG），ipsec 安全策略（NETLINK_XFRM），SELinux 事件通知（NETLINK_SELINUX），iSCSI 子系统（NETLINK_ISCSI），进程审计（NETLINK_AUDIT），转发信息表查询 （NETLINK_FIB_LOOKUP），netlink connector(NETLINK_CONNECTOR),netfilter 子系统（NETLINK_NETFILTER），IPv6 防火墙（NETLINK_IP6_FW），DECnet 路由信息（NETLINK_DNRTMSG），内核事件向用户态通知（NETLINK_KOBJECT_UEVENT），通用 netlink（NETLINK_GENERIC）。

 

　　Netlink 是一种在内核与用户应用间进行双向数据传输的非常好的方式，用户态应用使用标准的 socket API 就可以使用 netlink 提供的强大功能，内核态需要使用专门的内核 API 来使用 netlink。

 

　　Netlink 相对于系统调用，ioctl 以及 /proc 文件系统而言具有以下优点：

　　1　为了使用 netlink，用户仅需要在 include/linux/netlink.h 中增加一个新类型的 netlink 协议定义即可， 如 #define NETLINK_MYTEST 17 然后，内核和用户态应用就可以立即通过 socket API 使用该 netlink 协议类型进行数据交换。但系统调用需要增加新的系统调用，ioctl 则需要增加设备或文件，那需要不少代码，proc 文件系统则需要在 /proc 下添加新的文件或目录，那将使本来就混乱的 /proc 更加混乱。

　　2　netlink是一种异步通信机制，在内核与用户态应用之间传递的消息保存在socket缓存队列中，发送消息只是把消息保存在接收者的socket的接收队列，而不需要等待接收者收到消息，但系统调用与 ioctl 则是同步通信机制，如果传递的数据太长，将影响调度粒度。

　　3　使用 netlink 的内核部分可以采用模块的方式实现，使用 netlink 的应用部分和内核部分没有编译时依赖，但系统调用就有依赖，而且新的系统调用的实现必须静态地连接到内核中，它无法在模块中实现，使用新系统调用的应用在编译时需要依赖内核。

　　4　netlink支持多播，内核模块或应用可以把消息多播给一个netlink组，属于该neilink 组的任何内核模块或应用都能接收到该消息，内核事件向用户态的通知机制就使用了这一特性，任何对内核事件感兴趣的应用都能收到该子系统发送的内核事件，在 后面的文章中将介绍这一机制的使用。

　　5　内核可以使用 netlink 首先发起会话，但系统调用和 ioctl 只能由用户应用发起调用。

　　6　netlink 使用标准的 socket API，因此很容易使用，但系统调用和 ioctl则需要专门的培训才能使用。

 

用户态使用 netlink

 

　　用户态应用使用标准的socket APIs， socket(), bind(), sendmsg(), recvmsg() 和 close() 就能很容易地使用 netlink socket，查询手册页可以了解这些函数的使用细节。注意，使用 netlink 的应用必须包含头文件 linux/netlink.h。当然 socket 需要的头文件也必不可少，sys/socket.h。

 

　　为了创建一个 netlink socket，用户需要使用如下参数调用 socket():

int socket(AF_NETLINK, SOCK_RAW, netlink_type)

　　第一个参数必须是 AF_NETLINK 或 PF_NETLINK，在 Linux 中，它们俩实际为一个东西，它表示要使用netlink，

　　第二个参数必须是SOCK_RAW或SOCK_DGRAM，

　　第三个参数指定netlink协议类型，如前面讲的用户自定义协议类型NETLINK_MYTEST， NETLINK_GENERIC是一个通用的协议类型，它是专门为用户使用的，因此，用户可以直接使用它，而不必再添加新的协议类型。内核预定义的协议类型有：

#define NETLINK_ROUTE           0       /* Routing/device hook*/

#define NETLINK_W1                1       /* 1-wire subsystem*/

#define NETLINK_USERSOCK    2       /* Reserved for user mode socket protocols*/

#define NETLINK_FIREWALL     3       /* Firewalling hoo*/

#define NETLINK_INET_DIAG    4       /* INET 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  

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

 

　　函数 setsockopt() 用于设置套接口的选项。

 

int setsockopt(int socket, int level, int optname, const char FAR* optval, int optlen);

 

　　参数socket：标示一个套接口的描述字；

　　参数level：表示选项定义的层次，目前只支持SOL_SOCKET和IPPROTO_TCP层次。
　　参数optname：需设置的选项（见下）。
　　参数optval：指针，指向存放选项值的缓冲区。
   　参数optlen：optval缓冲区的长度。

 

optname支持下列选项。其中“类型”表明optval所指数据的类型。
选项        类型   　意义
SO_BROADCAST BOOL 允许套接口传送广播信息。
SO_DEBUG BOOL 记录调试信息。
SO_DONTLINER BOOL 不要因为数据未发送就阻塞关闭操作。设置本选项相当于将SO_LINGER的l_onoff元素置为零。
SO_DONTROUTE BOOL 禁止选径；直接传送。
SO_KEEPALIVE BOOL 发送“保持活动”包。
SO_LINGER struct linger FAR*   如关闭时有未发送数据，则逗留。
SO_OOBINLINE BOOL 在常规数据流中接收带外数据。
SO_RCVBUF int 为接收确定缓冲区大小。
SO_RCVBUFFORCE int 不受接收缓冲区大小上限的限制，可设置不小于2K的任意缓冲区大小
SO_REUSEADDR BOOL 允许套接口和一个已在使用中的地址捆绑（参见bind()）。
SO_SNDBUF int 指定发送缓冲区大小。
SO_SNDBUFFORCE  int 不受发送缓冲区大小上限的限制，可设置不小于2K的任意缓冲区大小
TCP_NODELAY BOOL 禁止发送合并的Nagle算法。

 

　　调用setsockopt()后设置缓冲区大小（SO_SNDBUF或SO_RCVBUF）后，首先内核要判断新设置的值是否超过上限，若超过，则取上限为新值，发送和接收缓冲区大小的上限值分别为sysctl_wmem_max和sysctl_rmem_max的2倍。这两个全局变量的值是相等的，都为(sizeof(struct sk_buff) + 256) * 256，大概为64K负载数据，由于struct sk_buff的影响，实际发送和接收缓冲区的大小最大都可设到210K左右。它们的下限是2K,即缓冲区大小不能低于2K。
　　SO_SNDBUF和SO_RCVBUF特殊的版本：SO_SNDBUFFORCE和SO_RCVBUFFORCE，它们不受发送和接收缓冲区大小上限的限制，可设置不小于2K的任意缓冲区大小。

 

optname不支持的BSD选项有：
选项名    类型 意义
SO_ACCEPTCONN BOOL 套接口在监听。
SO_ERROR int 获取错误状态并清除。
SO_RCVLOWAT int 接收低级水印。
SO_RCVTIMEO int 接收超时。
SO_SNDLOWAT int 发送低级水印。
SO_SNDTIMEO int 发送超时。
SO_TYPE     int 套接口类型。
IP_OPTIONS    在IP头中设置选项。

 

返回值：
　　若无错误发生，setsockopt()返回0。否则的话，返回SOCKET_ERROR错误，应用程序可通过WSAGetLastError()获取相应错误代码。错误代码：
WSANOTINITIALISED：在使用此API之前应首先成功地调用WSAStartup()。
WSAENETDOWN：WINDOWS套接口实现检测到网络子系统失效。
WSAEFAULT：optval不是进程地址空间中的一个有效部分。
WSAEINPROGRESS：一个阻塞的WINDOWS套接口调用正在运行中。
WSAEINVAL：level值非法，或optval中的信息非法。
WSAENETRESET：当SO_KEEPALIVE设置后连接超时。
WSAENOPROTOOPT：未知或不支持选项。其中，SOCK_STREAM类型的套接口不支持SO_BROADCAST选项，SOCK_DGRAM类型的套接口不支持SO_DONTLINGER 、SO_KEEPALIVE、SO_LINGER和SO_OOBINLINE选项。
WSAENOTCONN：当设置SO_KEEPALIVE后连接被复位。
WSAENOTSOCK：描述字不是一个套接口。

　　函数 bind() 用于把一个打开的 netlink socket 与 netlink 源 socket 地址绑定在一起。

 

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

 

　　netlink socket 的地址结构如下：

struct sockaddr_nl

{

　　sa_family_t    nl_family;

　　unsigned        short nl_pad;

　　__u32  nl_pid; 

　　__u32  nl_groups;

};

　　字段 nl_family 必须设置为 AF_NETLINK 或着 PF_NETLINK，

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

　　字段 nl_pid 为接收或发送消息的进程ID，如果希望内核处理消息或多播消息，就把该字段设置为 0，否则设置为处理消息的进程 ID(getpid())。传递给 bind 函数的地址的 nl_pid 字段应当设置为本进程的进程 ID，这相当于 netlink socket 的本地地址。但是，对于一个进程的多个线程使用 netlink socket 的情况，字段 nl_pid 则可以设置为其它的值，如：pthread_self() << 16 | getpid(); 因此字段 nl_pid 实际上未必是进程 ID,它只是用于区分不同的接收者或发送者的一个标识，用户可以根据自己需要设置该字段。

　　字段 nl_groups 用于指定多播组，bind 函数用于把调用进程加入到该字段指定的多播组，如果设置为 0，表示调用者不加入任何多播组。

 

　　为了发送一个 netlink 消息给内核或其他用户态应用，需要填充目标 netlink socket 地址，此时，字段 nl_pid 和 nl_groups 分别表示接收消息者的进程 ID 与多播组。如果字段 nl_pid 设置为 0，表示消息接收者为内核或多播组，如果 nl_groups为 0，表示该消息为单播消息，否则表示多播消息。

 

　　使用函数 sendmsg 发送 netlink 消息时还需要引用结构 struct msghdr、struct nlmsghdr 和 struct iovec结构。

 

　　struct msghdr 需如下设置：
struct msghdr msg;

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

msg.msg_name = (void *)&(nladdr);

msg.msg_namelen = sizeof(nladdr);

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

　　struct nlmsghdr 为 netlink socket 自己的消息头，这用于多路复用和多路分解 netlink 定义的所有协议类型以及其它一些控制，netlink 的内核实现将利用这个消息头来多路复用和多路分解已经其它的一些控制，因此它也被称为netlink 控制块。因此，应用在发送 netlink 消息时必须提供该消息头。

struct nlmsghdr

{

　　__u32 nlmsg_len;   /* Length of message */

　　__u16 nlmsg_type;  /* Message type*/

　　__u16 nlmsg_flags; /* Additional flags */

　　__u32 nlmsg_seq;   /* Sequence number */

　　__u32 nlmsg_pid;   /* Sending process PID */

};

　　字段 nlmsg_len 指定消息的总长度，包括紧跟该结构的数据部分长度以及该结构的大小，

　　字段 nlmsg_type 用于应用内部定义消息的类型，它对 netlink 内核实现是透明的，因此大部分情况下设置为 0，字段 nlmsg_flags 用于设置消息标志，可用的标志包括：

/* Flags values */

#define NLM_F_REQUEST           　1       /* It is request message. */

#define NLM_F_MULTI             　　2       /* Multipart message, terminated by NLMSG_DONE */

#define NLM_F_ACK               　　 4       /* Reply with ack, with zero or error code */

#define NLM_F_ECHO              　　8       /* Echo this request*/

/* Modifiers to GET request */

#define NLM_F_ROOT      　　　0x100   /* specify tree root    */

#define NLM_F_MATCH     　　  0x200   /* return all matching  */

#define NLM_F_ATOMIC            0x400   /* atomic GET*/

#define NLM_F_DUMP       (NLM_F_ROOT|NLM_F_MATCH)　　/* Modifiers to NEW request */

#define NLM_F_REPLACE          0x100   /* Override existing*/

#define NLM_F_EXCL                0x200   /* Do not touch, if it exists   */

#define NLM_F_CREATE            0x400   /* Create, if it does not exist */

#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 需要它进行一些复杂的操作），字段 nlmsg_seq 和 nlmsg_pid 用于应用追踪消息，前者表示顺序号，后者为消息来源进程 ID。

 

　　下面是一个示例：
#define MAX_MSGSIZE 1024

char buffer[] = "An example message";

struct nlmsghdr nlhdr;

nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_MSGSIZE));

strcpy(NLMSG_DATA(nlhdr),buffer);

nlhdr->nlmsg_len = NLMSG_LENGTH(strlen(buffer));

nlhdr->nlmsg_pid = getpid();  /* self pid */

nlhdr->nlmsg_flags = 0;

　　结构 struct iovec 用于把多个消息通过一次系统调用来发送，下面是该结构使用示例：
struct iovec iov;

iov.iov_base = (void *)nlhdr;

iov.iov_len = nlh->nlmsg_len;

msg.msg_iov = &iov;

msg.msg_iovlen = 1;

在完成以上步骤后，消息就可以通过下面语句直接发送，其中send只可用于基于连接的套接字，send 和 write唯一的不同点是标志的存在，当标志为0时，send等同于write。sendmsg既可用于无连接的套接字，也可用于基于连接的套接字。除了套接字设置为非阻塞模式，调用将会阻塞直到数据被发送完。

sendmsg(int socket, &msg, 0);

ssize_t recvmsg(int socket, struct msghdr *msg, 0);

　　应用接收消息时需要首先分配一个足够大的缓存来保存消息头以及消息的数据部分，然后填充消息头，添完后就可以直接调用函数 recvmsg() 来接收。

#define MAX_NL_MSG_LEN 1024　

struct sockaddr_nl nladdr;

struct msghdr msg;

struct iovec iov;

struct nlmsghdr * nlhdr;

nlhdr = (struct nlmsghdr *)malloc(MAX_NL_MSG_LEN);

iov.iov_base = (void *)nlhdr;

iov.iov_len = MAX_NL_MSG_LEN;

msg.msg_name = (void *)&(nladdr);

msg.msg_namelen = sizeof(nladdr);

msg.msg_iov = &iov;

msg.msg_iovlen = 1;

recvmsg(fd, &msg, 0);

 

　　在消息接收后，nlhdr指向接收到的消息的消息头，nladdr保存了接收到的消息的目标地址，宏NLMSG_DATA(nlhdr)返回指向消息的数据部分的指针。

 

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

#define NLMSG_ALIGNTO   4

#define NLMSG_ALIGN(len)  /

　　　( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )

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

#define NLMSG_LENGTH(len)  /

　　　((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))

　　宏NLMSG_LENGTH(len)用于计算数据部分长度为len时实际的消息长度。它一般用于分配消息缓存。

#define NLMSG_SPACE(len)  /

　　NLMSG_ALIGN(NLMSG_LENGTH(len))

　　宏NLMSG_SPACE(len)返回不小于NLMSG_LENGTH(len)且字节对齐的最小数值，它也用于分配消息缓存。

#define NLMSG_DATA(nlh)  /

　　 ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))

　　宏NLMSG_DATA(nlh)用于取得消息的数据部分的首地址，设置和读取消息数据部分时需要使用该宏。

#define NLMSG_NEXT(nlh,len)  /

　　((len) -= NLMSG_ALIGN((nlh)->nlmsg_len),  /

　　(struct nlmsghdr*)(((char*)(nlh)) + 　/

　　NLMSG_ALIGN((nlh)->nlmsg_len)))

　　宏NLMSG_NEXT(nlh,len)用于得到下一个消息的首地址，同时len也减少为剩余消息的总长度，该宏一般在一个消息被分成几个部分发送或接收时使用。

#define NLMSG_OK(nlh,len)  /

　　((len) >= (int)sizeof(struct nlmsghdr) && / 

　　(nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && /

　　(nlh)->nlmsg_len <= (len))

　　宏NLMSG_OK(nlh,len)用于判断消息是否有len这么长。

#define NLMSG_PAYLOAD(nlh,len)  /

　　((nlh)->nlmsg_len - NLMSG_SPACE((len)))

　　宏NLMSG_PAYLOAD(nlh,len)用于返回payload的长度。

 

　　也可以使用

int recv(int socket, char *buf, int len, 0);

ssize_t send(int socket, const void *buf, size_t len, 0);

 

　　函数close用于关闭打开的netlink socket。

 

netlink内核API

 

　　netlink的内核实现在.c文件net/core/af_netlink.c中，内核模块要想使用netlink，也必须包含头文件linux /netlink.h。内核使用netlink需要专门的API，这完全不同于用户态应用对netlink的使用。如果用户需要增加新的netlink协议类型，必须通过修改linux/netlink.h来实现，当然，目前的netlink实现已经包含了一个通用的协议类型 NETLINK_GENERIC以方便用户使用，用户可以直接使用它而不必增加新的协议类型。前面讲到，为了增加新的netlink协议类型，用户仅需增 加如下定义到linux/netlink.h就可以：

#define NETLINK_MYTEST  17

　　只要增加这个定义之后，用户就可以在内核的任何地方引用该协议。

　　在内核中，为了创建一个netlink socket用户需要调用如下函数：

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

　　参数unit表示netlink协议类型，如NETLINK_MYTEST，

　　参数input则为内核模块定义的netlink消息处理函数，当有消息到达这个netlink socket时，该input函数指针就会被引用。函数指针input的参数sk实际上就是函数netlink_kernel_create返回的struct sock指针，sock实际是socket的一个内核表示数据结构，用户态应用创建的socket在内核中也会有一个struct sock结构来表示。

　　下面是一个input函数的示例：

void input (struct sock *sk, int len)

{

　　struct sk_buff *skb;

　　struct nlmsghdr *nlh = NULL;

　　u8 *data = NULL;

　　while ((skb = skb_dequeue(&sk->receive_queue)) != NULL)

　　{ /* process netlink message pointed by skb->data */

　　　　nlh = (struct nlmsghdr *)skb->data;

　　　　data = NLMSG_DATA(nlh);

　　　　/* process netlink message with header pointed */

　　　　/*by   * nlh and data pointed by data  */

　　}

}

　　函数input()会在发送进程执行sendmsg()时被调用，这样处理消息比较及时，但是，如果消息特别长时，这样处理将增加系统调用 sendmsg()的执行时间，对于这种情况，可以定义一个内核线程专门负责消息接收，而函数input的工作只是唤醒该内核线程，这样sendmsg将 很快返回。

 

　　函数skb = skb_dequeue(&sk->receive_queue)用于取得socket sk的接收队列上的消息，返回为一个struct sk_buff的结构，skb->data指向实际的netlink消息。

 

　　函数skb_recv_datagram(nl_sk)也用于在netlink socket nl_sk上接收消息，与skb_dequeue的不同指出是，如果socket的接收队列上没有消息，它将导致调用进程睡眠在等待队列 nl_sk->sk_sleep，因此它必须在进程上下文使用，刚才讲的内核线程就可以采用这种方式来接收消息。

　　下面的函数input就是这种使用的示例：

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

　　当内核中发送netlink消息时，也需要设置目标地址与源地址，而且内核中消息是通过struct sk_buff来管理的， linux/netlink.h中定义了一个宏：#define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb)) 来方便消息的地址设置。

　　下面是一个消息地址设置的例子：
NETLINK_CB(skb).pid = 0;

NETLINK_CB(skb).dst_pid = 0;

NETLINK_CB(skb).dst_group = 1;

　　字段pid表示消息发送者进程ID，也即源地址，对于内核，它为 0，

　　dst_pid 表示消息接收者进程 ID，也即目标地址，如果目标为组或内核，它设置为 0，

　　dst_group 表示目标组地址，如果它目标为某一进程或内核，dst_group 应当设置为 0。

 

　　在内核中，模块调用函数 netlink_unicast 来发送单播消息：

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

　　参数sk为函数netlink_kernel_create()返回的socket，

　　参数skb存放消息，它的data字段指向要发送的 netlink消息结构，而skb的控制块保存了消息的地址信息，前面的宏NETLINK_CB(skb)就用于方便设置该控制块，

　　参数pid为接收消息进程的pid，

　　参数nonblock表示该函数是否为非阻塞，如果为1

 

　　该函数将在没有接收缓存可利用时立即返回，而如果为0，该函 数在没有接收缓存可利用时睡眠。

 

　　内核模块或子系统也可以使用函数netlink_broadcast来发送广播消息：

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

　　前面的三个参数与netlink_unicast相同，

　　参数group为接收消息的多播组，该参数的每一个代表一个多播组，因此如果发送给多个多播 组，就把该参数设置为多个多播组组ID的位或。

　　参数allocation为内核内存分配类型，一般地为GFP_ATOMIC或 GFP_KERNEL，GFP_ATOMIC用于原子的上下文（即不可以睡眠），而GFP_KERNEL用于非原子上下文。

 

　　在内核中使用函数sock_release来释放函数netlink_kernel_create()创建的netlink socket：

void sock_release(struct socket * sock);

　　注意函数netlink_kernel_create()返回的类型为struct sock，因此函数sock_release应该这种调用：

sock_release(sk->sk_socket);

　　sk为函数netlink_kernel_create()的返回值。

 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

 

 

PF_NETLINK应用实例

NETLINK_KOBJECT_UEVENT具体实现－－udev实现原理
   

 

　　相对于linux来说，udev还是一个新事物。然而，尽管它03年才出现，尽管它很低调(J)，但它无疑已经成为linux下不可或缺的组件了。udev是什么？它是如何实现的？最近研究Linux设备管理时，花了一些时间去研究udev的实现。
　　
　　udev是什么？u 是指user space，dev是指device，udev是用户空间的设备驱动程序吗？最初我也这样认为，调试内核空间的程序要比调试用户空间的程序复杂得多，内核空间的程序的BUG所引起的后果也严重得多，device driver是内核空间中所占比较最大的代码，如果把这些device driver中硬件无关的代码，从内核空间移动到用户空间，自然是一个不错的想法。
　　
　　但我的想法并不正确，udev的文档是这样说的，
　　1. dynamic replacement for /dev。作为devfs的替代者，传统的devfs不能动态分配major和minor的值，而major和minor非常有限，很快就会用完了。 udev能够像DHCP动态分配IP地址一样去动态分配major和minor。
　　
　　2. device naming。提供设备命名持久化的机制。传统设备命名方式不具直观性，像/dev/hda1这样的名字肯定没有boot_disk这样的名字直观。udev能够像DNS解析域名一样去给设备指定一个有意义的名称。
　　
　　3. API to access info about current system devices 。提供了一组易用的API去操作sysfs，避免重复实现同样的代码，这没有什么好说的。
　　
　　我们知道，用户空间的程序与设备通信的方法，主要有以下几种方式，
　　1. 通过ioperm获取操作IO端口的权限，然后用inb/inw/ inl/ outb/outw/outl等函数，避开设备驱动程序，直接去操作IO端口。（没有用过）
　　2. 用ioctl函数去操作/dev目录下对应的设备，这是设备驱动程序提供的接口。像键盘、鼠标和触摸屏等输入设备一般都是这样做的。
　　3. 用write/read/mmap去操作/dev目录下对应的设备，这也是设备驱动程序提供的接口。像framebuffer等都是这样做的。
　　
　　上面的方法在大多数情况下，都可以正常工作，但是对于热插拨(hotplug)的设备，比如像U盘，就有点困难了，因为你不知道：什么时候设备插上了，什么时候设备拔掉了。这就是所谓的hotplug问题了。
　　
　　处理hotplug传统的方法是，在内核中执行一个称为hotplug的程序，相关参数通过环境变量传递过来，再由hotplug通知其它关注 hotplug事件的应用程序。这样做不但效率低下，而且感觉也不那么优雅。新的方法是采用NETLINK实现的，这是一种特殊类型的socket，专门用于内核空间与用户空间的异步通信。下面的这个简单的例子，可以监听来自内核hotplug的事件。

 
　　#include ....
　　
　　staticintinit_hotplug_sock(void)
　　{
　　structsockaddr_nl snl
　　constintbuffersize= 16 * 1024 * 1024;
　　intretval
　　
　　memset(&snl, 0x00, sizeof(structsockaddr_nl));
　　snl.nl_family = AF_NETLINK;
　　snl.nl_pid = getpid();
　　snl.nl_groups = 1;
　　
　　inthotplug_sock= socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
　　if(hotplug_sock== -1) {
　　printf("error getting socket: %s", strerror(errno));
　　return-1;
　　}
　　
　　/* set receive buffersize */
　　setsockopt(hotplug_sock, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize));
　　
　　retval= bind(hotplug_sock, (structsockaddr*) &snl, sizeof(structsockaddr_nl));
　　if(retval<0) {
　　printf("bind failed: %s", strerror(errno));
　　close(hotplug_sock);
　　hotplug_sock= -1;
　　return-1;
　　}
　　
　　returnhotplug_sock
　　}
　　
　　#define UEVENT_BUFFER_SIZE 2048
　　
　　intmain(intargc, char* argv[])
　　{
　　inthotplug_sock = init_hotplug_sock();
　　
　　while(1)
　　{
　　charbuf[UEVENT_BUFFER_SIZE*2] = {0};
　　recv(hotplug_sock, &buf, sizeof(buf), 0);
　　printf("%s/n", buf);
　　}
　　
　　return0;
　　}
　　
　　编译：
　　gcc -g hotplug.c -o hotplug_monitor
　　
　　运行后插/拔U盘，可以看到：
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/usbdev2.2_ep00
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0
　　add@/class/scsi_host/host2
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep81
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep02
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep83
　　add@/class/usb_device/usbdev2.2
　　add@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/host2/target2:0:0/2:0:0:0
　　add@/class/scsi_disk/2:0:0:0
　　add@/block/sda
　　add@/block/sda/sda1
　　add@/class/scsi_device/2:0:0:0
　　add@/class/scsi_generic/sg0
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep81
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep02
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/usbdev2.2_ep83
　　remove@/class/scsi_generic/sg0
　　remove@/class/scsi_device/2:0:0:0
　　remove@/class/scsi_disk/2:0:0:0
　　remove@/block/sda/sda1
　　remove@/block/sda
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0/host2/target2:0:0/2:0:0:0
　　remove@/class/scsi_host/host2
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/2-1:1.0
　　remove@/class/usb_device/usbdev2.2
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1/usbdev2.2_ep00
　　remove@/devices/pci0000:00/0000:00:1d.1/usb2/2-1
　　
　　udev的主体部分在udevd.c文件中，它主要监控来自4个文件描述符的事件/消息，并做出处理：
　　1. 来自客户端的控制消息。这通常由udevcontrol命令通过地址为/org/kernel/udev/udevd的本地socket，向udevd发送的控制消息。其中消息类型有：
　　l UDEVD_CTRL_STOP_EXEC_QUEUE 停止处理消息队列。
　　l UDEVD_CTRL_START_EXEC_QUEUE 开始处理消息队列。
　　l UDEVD_CTRL_SET_LOG_LEVEL 设置LOG的级别。
　　l UDEVD_CTRL_SET_MAX_CHILDS 设置最大子进程数限制。好像没有用。
　　l UDEVD_CTRL_SET_MAX_CHILDS_RUNNING 设置最大运行子进程数限制(遍历proc目录下所有进程，根据session的值判断)。
　　l UDEVD_CTRL_RELOAD_RULES 重新加载配置文件。
　　2. 来自内核的hotplug事件。如果有事件来源于hotplug，它读取该事件，创建一个udevd_uevent_msg对象，记录当前的消息序列号，设置消息的状态为EVENT_QUEUED,然后并放入running_list和exec_list两个队列中，稍后再进行处理。
　　3. 来自signal handler中的事件。signal handler是异步执行的，即使有signal产生，主进程的select并不会唤醒，为了唤醒主进程的select，它建立了一个管道，在 signal handler中，向该管道写入长度为1个子节的数据，这样就可以唤醒主进程的select了。
　　4. 来自配置文件变化的事件。udev通过文件系统inotify功能，监控其配置文件目录/etc/udev/rules.d，一旦该目录中文件有变化，它就重新加载配置文件。
　　
　　其中最主要的事件，当然是来自内核的hotplug事件，如何处理这些事件是udev的关键。udev本身并不知道如何处理这些事件，也没有必要知道，因为它只实现机制，而不实现策略。事件的处理是由配置文件决定的，这些配置文件即所谓的rule。
　　
　　关于rule的编写方法可以参考《writing_udev_rules》，udev_rules.c实现了对规则的解析。
　　
　　在规则中，可以让外部应用程序处理某个事件，这有两种方式，一种是直接执行命令，通常是让modprobe去加载驱动程序，或者让mount去加载分区。另外一种是通过本地socket发送消息给某个应用程序。
　　
　　在udevd.c:udev_event_process函数中，我们可以看到，如果RUN参数以”socket:”开头则认为是发到socket，否则认为是执行指定的程序。
　　
　　下面的规则是执行指定程序：
　　60-pcmcia.rules: RUN+="/sbin/modprobe pcmcia"
　　
　　下面的规则是通过socket发送消息：
　　90-hal.rules:RUN+="socket:/org/freedesktop/hal/udev_event"
　　
　　hal正是我们下一步要关心的，接下来我会分析HAL的实现原理。