Netlink 内核实现分析 3
Netlink IPC 数据结构
#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
/*
其中（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个）。
*/
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 */
};
netlink消息同IP消息一样，也需要遵循协议要求的格式，每个netlink消息的开头是固定长度的netlink报头，报头后才是实际的载荷。netlink报头一共占16个字节。
/*
netlink消息同IP消息一样，也需要遵循协议要求的格式，每个netlink消息的开头是固定长度的netlink报头，
报头后才是实际的载荷。netlink报头一共占16个字节，具体内容即同struct nlmsghdr中定义的一样。
*/
struct nlmsghdr {
__u32 nlmsg_len; /* Length of message including header */
__u16 nlmsg_type; /* Message content nlmsg_type：消息状态，
内核在include/uapi/linux/netlink.h中定义了以下4种通用的消息类型，它们分别是NLMSG_NOOP NLMSG_ERROR so on
除了这4种类型的消息以外，不同的netlink协议也可以自行添加自己所特有的消息类型，
但是内核定义了类型保留宏（#define NLMSG_MIN_TYPE 0x10），即小于该值的消息类型值由内核保留，不可用。*/
__u16 nlmsg_flags; /* Additional flags NLM_F_REQUEST so on */
__u32 nlmsg_seq; /* Sequence number 消息序列号，用以将消息排队，有些类似TCP协议中的序号*/
__u32 nlmsg_pid; /* Sending process port ID 发送端口的ID号，对于内核来说该值就是0，对于用户进程来说就是其socket所绑定的ID号*/
};
消息类型：
nlmsg_type：消息状态其取值有：
NLMSG_NOOP：不执行任何动作，必须将该消息丢弃；
NLMSG_ERROR：消息发生错误；
NLMSG_DONE：标识分组消息的末尾；
NLMSG_OVERRUN：缓冲区溢出，表示某些消息已经丢失。
/*
除了这4种类型的消息以外，不同的netlink协议也可以自行添加自己所特有的消息类型，
但是内核定义了类型保留宏（#define NLMSG_MIN_TYPE 0x10），即小于该值的消息类型值由内核保留，不可用。
*/
#define NLMSG_MIN_TYPE 0x10 /* < 0x10: reserved control messages */
Netlink消息处理宏
消息处理的宏定义
#define NLMSG_ALIGNTO 4U
#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) ) /* 对len执行4字节对齐 */
#define NLMSG_HDRLEN ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr))) /* netlink消息头长度 */
#define NLMSG_LENGTH(len) ((len) + NLMSG_HDRLEN) /* netlink消息载荷len加上消息头 */
#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len)) /* 对netlink消息全长执行字节对齐 */
#define NLMSG_DATA(nlh) ((void*)(((char*)nlh) + NLMSG_LENGTH(0))) /* 获取netlink消息实际载荷位置 */
#define NLMSG_NEXT(nlh,len) ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
(struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))/* 取得下一个消息的首地址，同时len也减少为剩余消息的总长度 */
#define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
(nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
(nlh)->nlmsg_len <= (len)) /* 验证消息的长度 */
#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len))) /* 返回PAYLOAD的长度 */
/*
netlink的消息头后面跟着的是消息的有效载荷部分，它采用的是格式为“类型——长度——值”，简写TLV。
其中类型和长度使用属性头nlattr来表示。其中nla_len表示属性长度；nla_type表示属性类型，
它可以取值为以下几种类型（定义在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)---^
*
* Data Structures:
* struct nlmsghdr netlink message header
*
* Message Construction:
* nlmsg_new() create a new netlink message
* nlmsg_put() add a netlink message to an skb
* nlmsg_put_answer() callback based nlmsg_put()
* nlmsg_end() finalize netlink message
* nlmsg_get_pos() return current position in message
* nlmsg_trim() trim part of message
* nlmsg_cancel() cancel message construction
* nlmsg_free() free a netlink message
*
* Message Sending:
* nlmsg_multicast() multicast message to several groups
* nlmsg_unicast() unicast a message to a single socket
* nlmsg_notify() send notification message
*
* Message Length Calculations:
* nlmsg_msg_size(payload) length of message w/o padding
* nlmsg_total_size(payload) length of message w/ padding
* nlmsg_padlen(payload) length of padding at tail
*
* Message Payload Access:
* nlmsg_data(nlh) head of message payload
* nlmsg_len(nlh) length of message payload
* nlmsg_attrdata(nlh, hdrlen) head of attributes data
* nlmsg_attrlen(nlh, hdrlen) length of attributes data
*
* Message Parsing:
* nlmsg_ok(nlh, remaining) does nlh fit into remaining bytes?
* nlmsg_next(nlh, remaining) get next netlink message
* nlmsg_parse() parse attributes of a message
* nlmsg_find_attr() find an attribute in a message
* nlmsg_for_each_msg() loop over all messages
* nlmsg_validate() validate netlink message incl. attrs
* nlmsg_for_each_attr() loop over all attributes
*
* Misc:
* nlmsg_report() report back to application?
*
* ------------------------------------------------------------------------
* Attributes Interface
* ------------------------------------------------------------------------
*
* Attribute Format:
* <------- nla_total_size(payload) ------->
* <---- nla_attr_size(payload) ----->
* +----------+- - -+- - - - - - - - - +- - -+-------- - -
* | Header | Pad | Payload | Pad | Header
* +----------+- - -+- - - - - - - - - +- - -+-------- - -
* <- nla_len(nla) -> ^
* nla_data(nla)----^ |
* nla_next(nla)-----------------------------'
*
* Data Structures:
* struct nlattr netlink attribute header
*
* Attribute Construction:
* nla_reserve(skb, type, len) reserve room for an attribute
* nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
* nla_put(skb, type, len, data) add attribute to skb
* nla_put_nohdr(skb, len, data) add attribute w/o hdr
* nla_append(skb, len, data) append data to skb
*
* Attribute Construction for Basic Types:
* nla_put_u8(skb, type, value) add u8 attribute to skb
* nla_put_u16(skb, type, value) add u16 attribute to skb
* nla_put_u32(skb, type, value) add u32 attribute to skb
* nla_put_u64_64bits(skb, type,
* value, padattr) add u64 attribute to skb
* nla_put_s8(skb, type, value) add s8 attribute to skb
* nla_put_s16(skb, type, value) add s16 attribute to skb
* nla_put_s32(skb, type, value) add s32 attribute to skb
* nla_put_s64(skb, type, value,
* padattr) add s64 attribute to skb
* nla_put_string(skb, type, str) add string attribute to skb
* nla_put_flag(skb, type) add flag attribute to skb
* nla_put_msecs(skb, type, jiffies,
* padattr) add msecs attribute to skb
* nla_put_in_addr(skb, type, addr) add IPv4 address attribute to skb
* nla_put_in6_addr(skb, type, addr) add IPv6 address attribute to skb
*
* Nested Attributes Construction:
* nla_nest_start(skb, type) start a nested attribute
* nla_nest_end(skb, nla) finalize a nested attribute
* nla_nest_cancel(skb, nla) cancel nested attribute construction
*
* Attribute Length Calculations:
* nla_attr_size(payload) length of attribute w/o padding
* nla_total_size(payload) length of attribute w/ padding
* nla_padlen(payload) length of padding
*
* Attribute Payload Access:
* nla_data(nla) head of attribute payload
* nla_len(nla) length of attribute payload
*
* Attribute Payload Access for Basic Types:
* nla_get_u8(nla) get payload for a u8 attribute
* nla_get_u16(nla) get payload for a u16 attribute
* nla_get_u32(nla) get payload for a u32 attribute
* nla_get_u64(nla) get payload for a u64 attribute
* nla_get_s8(nla) get payload for a s8 attribute
* nla_get_s16(nla) get payload for a s16 attribute
* nla_get_s32(nla) get payload for a s32 attribute
* nla_get_s64(nla) get payload for a s64 attribute
* nla_get_flag(nla) return 1 if flag is true
* nla_get_msecs(nla) get payload for a msecs attribute
*
* Attribute Misc:
* nla_memcpy(dest, nla, count) copy attribute into memory
* nla_memcmp(nla, data, size) compare attribute with memory area
* nla_strlcpy(dst, nla, size) copy attribute to a sized string
* nla_strcmp(nla, str) compare attribute with string
*
* Attribute Parsing:
* nla_ok(nla, remaining) does nla fit into remaining bytes?
* nla_next(nla, remaining) get next netlink attribute
* nla_validate() validate a stream of attributes
* nla_validate_nested() validate a stream of nested attributes
* nla_find() find attribute in stream of attributes
* nla_find_nested() find attribute in nested attributes
* nla_parse() parse and validate stream of attrs
* nla_parse_nested() parse nested attribuets
* nla_for_each_attr() loop over all attributes
* nla_for_each_nested() loop over the nested attributes
*=========================================================================
*/
socket 发送netlink消息
#define TEST_DATA_LEN 16
#define TEST_DATA "netlink send test" /* 仅作为示例，内核NETLINK_ROUTE套接字无法解析 */ struct sockaddr_nl nladdr;
struct msghdr msg;
struct nlmsghdr *nlhdr;
struct iovec iov; /* 填充目的地址结构 */
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
nladdr.nl_pid = 0; /* 地址为内核 */
nladdr.nl_groups = 0; /* 单播 */ /* 填充netlink消息头 */
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(TEST_DATA_LEN)); nlhdr->nlmsg_len = NLMSG_LENGTH(TEST_DATA_LEN);
nlhdr->nlmsg_flags = NLM_F_REQUEST;
nlhdr->nlmsg_pid = get_pid(); /* 当前套接字所绑定的ID号（此处为本进程的PID） */
nlhdr->nlmsg_seq = 0; /* 填充netlink消息实际载荷 */
strcpy(NLMSG_DATA(nlhdr), TEST_DATA);
iov.iov_base = (void *)nlhdr;
iov.iov_len = nlhdr->nlmsg_len; /* 填充数据消息结构 */
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&(nladdr);
msg.msg_namelen = sizeof(nladdr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1; /* 发送netlink消息 */
sendmsg (sock, &msg, 0); /* sock 为NETLINK_ROUTE类型套接字 */
这里调用了socket所绑定协议特有的数据发送钩子函数，其中最后一个参数为msg->msg_iter->count，
即消息实际载荷的总长度。在前一篇文章中已经看到了对于netlink类型的套接字来说该函数被注册为netlink_sendmsg()，
下面来分析这个函数，这个函数较长，分段分析：
根据socket 层代码分析可知：
send(fd......) 最后回调socket所绑定协议特有的数据发送钩子函数，其中最后一个参数为msg->msg_iter->count，即消息实际载荷的总长度。
对于netlink类型的套接字来说该函数被注册为netlink_sendmsg()
static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
{
struct sock *sk = sock->sk;
struct netlink_sock *nlk = nlk_sk(sk);
DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
u32 dst_portid;
u32 dst_group;
struct sk_buff *skb;
int err;
struct scm_cookie scm;
u32 netlink_skb_flags = 0; if (msg->msg_flags&MSG_OOB)
return -EOPNOTSUPP;
/*这里定义了一个struct sockaddr_nl *addr指针，它指向了msg->msg_name表示消息的目的地址（会做地址长度检查）；
然后调用scm_send()发送消息辅助数据
*/err = scm_send(sock, msg, &scm, true);
if (err < 0)
return err;
/*
如果用户指定了netlink消息的目的地址，则对其进行校验，然后判断当前netlink协议的NL_CFG_F_NONROOT_SEND标识是否设置，
如果设置了该标识则允许非root用户发送组播，对于NETLINK_ROUTE类型的netlink套接字，
并没有设置该标识，表明非root用户不能发送组播消息；
然后设置NETLINK_SKB_DST标识。如果用户没有指定netlink消息的目的地址，
则使用netlink套接字默认的（该值默认为0，会在调用connect系统调用时在netlink_connect()中被赋值为用户设置的值）。
注意这里dst_group经过ffs的处理后转化为组播地址位数（找到最低有效位）。
?
*/
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);//用于查找一个整数中的第一个置位值(也就是bit为1的位)
err = -EPERM;
if ((dst_group || dst_portid) &&
!netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
goto out;
netlink_skb_flags |= NETLINK_SKB_DST;
} else {//没有指定netlink 消息接收地址 使用默认的
dst_portid = nlk->dst_portid;
dst_group = nlk->dst_group;
} if (!nlk->bound) {//来判断当前的netlink套接字是否被绑定过，如果没有绑定过这里调用netlink_autobind()进行动态绑定
err = netlink_autobind(sock);
if (err)
goto out;
} else {
/* Ensure nlk is hashed and visible. */
smp_rmb();
}
//接下来判断需要发送的数据是否过长（长于发送缓存大小），然后通过netlink_alloc_large_skb分配skb结构（传入的参数为消息载荷的长度以及组播地址）。
err = -EMSGSIZE;
if (len > sk->sk_sndbuf - 32)
goto out;
err = -ENOBUFS;
skb = netlink_alloc_large_skb(len, dst_group);
if (skb == NULL)
goto out;
/*
在成功创建skb结构之后，这里就开始初始化它，这里使用到了skb中的扩展cb字段（char cb[48] __aligned(8)，
一共48个字节用于存放netlink的地址和标识相关的附加信息足够了），同时使用宏NETLINK_CB来操作这些字段。
netlink将skb的cb字段强制定义为struct netlink_skb_parms结构：
*/
NETLINK_CB(skb).portid = nlk->portid;
NETLINK_CB(skb).dst_group = dst_group;
NETLINK_CB(skb).creds = scm.creds;
NETLINK_CB(skb).flags = netlink_skb_flags;
/*
其中portid表示原端套接字所绑定的id，dst_group表示消息目的组播地址，flag为标识，sk指向原端套接字的sock结构。
这里首先将套接字绑定的portid赋值到skb得cb字段中、同时设置组播地址的数量以及netlink_skb标识（这里是已经置位NETLINK_SKB_DST）。
接下来调用最关键的调用memcpy_from_msg拷贝数据，它首先调用skb_put调整skb->tail指针，
然后执行copy_from_iter(data, len, &msg->msg_iter)将数据从msg->msg_iter中传输到skb->data中
（这是第一次内存拷贝动作！将用户空间数据直接拷贝到内核skb中）。
*/
err = -EFAULT;
if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
kfree_skb(skb);
goto out;
} err = security_netlink_send(sk, skb);
if (err) {
kfree_skb(skb);
goto out;
}
/*
如果是组播发送则调用netlink_broadcast()发送消息，否则调用netlink_unicast()发送单播消息
*/
if (dst_group) {
atomic_inc(&skb->users);
netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
}
err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT); out:
scm_destroy(&scm);
return err;
}
单播发送函数netlink_unicast()
/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
u32 portid, int nonblock)
{
struct sock *sk;
int err;
long timeo;
/*
这里首先调用netlink_trim()重新裁剪skb的数据区的大小，这可能会clone出一个新的skb结构同时重新分配skb->data的内存空间
（这就出现了第三次的内存拷贝动作！），当然如果原本skb中多余的内存数据区非常小或者该内存空间是在vmalloc空间中的就不会执行上述操作，
我们现在跟随的情景上下文中就是后一种情况，并不会重新分配空间。
接下来记下发送超时等待时间，如果已经设置了MSG_DONTWAIT标识，则等待时间为0，否则返回sk->sk_sndtimeo
（该值在sock初始化时由sock_init_data()函数赋值为MAX_SCHEDULE_TIMEOUT）。 */
skb = netlink_trim(skb, gfp_any()); timeo = sock_sndtimeo(ssk, nonblock);
retry:
sk = netlink_getsockbyportid(ssk, portid);//根据目的portid号和原端sock结构查找目的端的sock结构
if (IS_ERR(sk)) {
kfree_skb(skb);
return PTR_ERR(sk);
}
if (netlink_is_kernel(sk))//目的地址是内核空间，则调用netlink_unicast_kernel向内核进行单播，入参是目的sock、数据skb 原端sock。
return netlink_unicast_kernel(sk, skb, ssk);
//这里首先sk_filter执行防火墙的过滤，确保可以发送以后调用netlink_attachskb将要发送的skb绑定到netlink sock上
if (sk_filter(sk, skb)) {
err = skb->len;
kfree_skb(skb);
sock_put(sk);
return err;
}
/*
目的sock的接收缓冲区剩余的的缓存大小小于已经提交的数据量，或者标志位已经置位了阻塞标识NETLINK_CONGESTED，
这表明数据不可以立即的送到目的端的接收缓存中。因此，
在原端不是内核socket且没有设置非阻塞标识的情况下会定义一个等待队列并等待指定的时间并返回1，
否则直接丢弃该skb数据包并返回失败。
若目的端的接收缓存区空间足够，就会调用netlink_skb_set_owner_r进行绑定。
回到netlink_unicast()函数中，可以看到若执行netlink_attachskb()的返回值为1，就会再次尝试发送操作。
最后调用netlink_sendskb()执行发送操作
*/
err = netlink_attachskb(sk, skb, &timeo, ssk);
if (err == 1)
goto retry;
if (err)
return err; return netlink_sendskb(sk, skb);
/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
u32 portid, int nonblock)
{
struct sock *sk;
int err;
long timeo;
/*
这里首先调用netlink_trim()重新裁剪skb的数据区的大小，这可能会clone出一个新的skb结构同时重新分配skb->data的内存空间
（这就出现了第三次的内存拷贝动作！），当然如果原本skb中多余的内存数据区非常小或者该内存空间是在vmalloc空间中的就不会执行上述操作，
我们现在跟随的情景上下文中就是后一种情况，并不会重新分配空间。
接下来记下发送超时等待时间，如果已经设置了MSG_DONTWAIT标识，则等待时间为0，否则返回sk->sk_sndtimeo
（该值在sock初始化时由sock_init_data()函数赋值为MAX_SCHEDULE_TIMEOUT）。 */
skb = netlink_trim(skb, gfp_any()); timeo = sock_sndtimeo(ssk, nonblock);
retry:
sk = netlink_getsockbyportid(ssk, portid);//根据目的portid号和原端sock结构查找目的端的sock结构
if (IS_ERR(sk)) {
kfree_skb(skb);
return PTR_ERR(sk);
}
if (netlink_is_kernel(sk))//目的地址是内核空间，则调用netlink_unicast_kernel向内核进行单播，入参是目的sock、数据skb 原端sock。
return netlink_unicast_kernel(sk, skb, ssk);
//这里首先sk_filter执行防火墙的过滤，确保可以发送以后调用netlink_attachskb将要发送的skb绑定到netlink sock上
if (sk_filter(sk, skb)) {
err = skb->len;
kfree_skb(skb);
sock_put(sk);
return err;
}
/*
目的sock的接收缓冲区剩余的的缓存大小小于已经提交的数据量，或者标志位已经置位了阻塞标识NETLINK_CONGESTED，
这表明数据不可以立即的送到目的端的接收缓存中。因此，
在原端不是内核socket且没有设置非阻塞标识的情况下会定义一个等待队列并等待指定的时间并返回1，
否则直接丢弃该skb数据包并返回失败。
若目的端的接收缓存区空间足够，就会调用netlink_skb_set_owner_r进行绑定。
回到netlink_unicast()函数中，可以看到若执行netlink_attachskb()的返回值为1，就会再次尝试发送操作。
最后调用netlink_sendskb()执行发送操作
*/
err = netlink_attachskb(sk, skb, &timeo, ssk);
if (err == 1)
goto retry;
if (err)
return err; return netlink_sendskb(sk, skb);
}
EXPORT_SYMBOL(netlink_unicast)
单播发送消息：
static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
{
int len = skb->len; netlink_deliver_tap(skb);
//这里的sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，进入分析一下
//对于内核的netlink来说内核netlink的创建函数中已经将其注册为 netlink_data_ready 所以内核不能收到组播
/*
static void netlink_data_ready(struct sock *sk)
{
BUG();
}
*/
skb_queue_tail(&sk->sk_receive_queue, skb);
sk->sk_data_ready(sk);//里唤醒目的接收端socket的等待队列，这样应用层套接字就可以接收并处理消息了。
return len;
}
对于根据portid 查找sk
首先调用netlink_lookup执行查找，查找的命名空间和协议号同原端sock，它会从nl_table[protocol]的哈希表中找到已经注册的目的端sock套接字。找到以后执行校验，如若找到的socket已经connect了，则它的目的portid必须是原端的portid。
接下来判断目的的netlink socket是否是内核的netlink socket
static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
struct sock *ssk)
{
int ret;
struct netlink_sock *nlk = nlk_sk(sk);
/*
目标netlink套接字是否注册了netlink_rcv()接收函数，如果没有则直接丢弃该数据包，否则继续发送流程，这里首先设置一些标识：
skb->sk = sk; 将目的sock赋值给skb->sk指针
skb->destructor = netlink_skb_destructor; 注册destructor钩子函数
NETLINK_CB(skb).sk = ssk; 将原端的sock保存早skb的cb扩展字段中
最后就调用了nlk->netlink_rcv(skb)函数将消息送到内核中的目的netlink套接字中了 在内核注册netlink套接字的时候已经将其接收函数注册到了netlink_rcv中：
struct sock *
__netlink_kernel_create(struct net *net, int unit, struct module *module,
struct netlink_kernel_cfg *cfg)
{
......
if (cfg && cfg->input)
nlk_sk(sk)->netlink_rcv = cfg->input;
对于NETLINK_ROUTE类型的套接字来说就是rtnetlink_rcv了，netlink_rcv()钩子函数会接收并解析用户传下来的数据
*/
ret = -ECONNREFUSED;
if (nlk->netlink_rcv != NULL) {
ret = skb->len;
netlink_skb_set_owner_r(skb, sk);
NETLINK_CB(skb).sk = ssk;
netlink_deliver_tap_kernel(sk, ssk, skb);
nlk->netlink_rcv(skb);
consume_skb(skb);
} else {
kfree_skb(skb);
}
sock_put(sk);
return ret;
}
/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/
Netlink发送广播消息：
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)
{
struct net *net = sock_net(ssk);
struct netlink_broadcast_data info;
struct sock *sk; 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; /* While we sleep in clone, do not allow to change socket list */ netlink_lock_table();
/*
初始化netlink组播数据结构netlink_broadcast_data，其中info.group中保存了目的组播地址，
然后从nl_table[ssk->sk_protocol].mc_list里边查找加入组播组的socket，并调用do_one_broadcast()函数依次发送组播数据：
*/
sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
do_one_broadcast(sk, &info); consume_skb(skb); netlink_unlock_table(); if (info.delivery_failure) {
kfree_skb(info.skb2);
return -ENOBUFS;
}
consume_skb(info.skb2); if (info.delivered) {
if (info.congested && gfpflags_allow_blocking(allocation))
yield();
return 0;
}
return -ESRCH;
}
static void do_one_broadcast(struct sock *sk,
struct netlink_broadcast_data *p)
{
struct netlink_sock *nlk = nlk_sk(sk);
int val; if (p->exclude_sk == sk)
return;
//这里会确保原端sock和目的端sock不是同一个，它们属于同一个网络命名空间，目的的组播地址为发送的目的组播地址等等
if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
!test_bit(p->group - 1, nlk->groups))
return; if (!net_eq(sock_net(sk), p->net)) {
if (!(nlk->flags & NETLINK_F_LISTEN_ALL_NSID))
return; if (!peernet_has_id(sock_net(sk), p->net))
return; if (!file_ns_capable(sk->sk_socket->file, p->net->user_ns,
CAP_NET_BROADCAST))
return;
} if (p->failure) {
netlink_overrun(sk);
return;
} sock_hold(sk);
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 ownership may have been set when
* delivered to a previous socket.
*/
skb_orphan(p->skb2);
}
}
if (p->skb2 == NULL) {
netlink_overrun(sk);
/* Clone failed. Notify ALL listeners. */
p->failure = 1;
if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
p->delivery_failure = 1;
goto out;
}
if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
kfree_skb(p->skb2);
p->skb2 = NULL;
goto out;
}
if (sk_filter(sk, p->skb2)) {
kfree_skb(p->skb2);
p->skb2 = NULL;
goto out;
}
NETLINK_CB(p->skb2).nsid = peernet2id(sock_net(sk), p->net);
NETLINK_CB(p->skb2).nsid_is_set = true;
/*
内核netlink套接字是无论如何也不应该接收到组播消息的。
但是对于应用层netlink套接字，该sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，
这个函数后面再分析。
*/
val = netlink_broadcast_deliver(sk, p->skb2);//netlink_broadcast_deliver()函数对目的sock发送数据skb：
if (val < 0) {
netlink_overrun(sk);
if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
p->delivery_failure = 1;
} else {
p->congested |= val;
p->delivered = 1;
p->skb2 = NULL;
}
out:
sock_put(sk);
}
内核netlink套接字是无论如何也不应该接收到组播消息的。但是对于应用层netlink套接字，该sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()
static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
{
int len = skb->len; netlink_deliver_tap(skb);
//这里的sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，进入分析一下
//对于内核的netlink来说内核netlink的创建函数中已经将其注册为 netlink_data_ready 所以内核不能收到组播
/*
static void netlink_data_ready(struct sock *sk)
{
BUG();
}
*/
skb_queue_tail(&sk->sk_receive_queue, skb);
sk->sk_data_ready(sk);//里唤醒目的接收端socket的等待队列，这样应用层套接字就可以接收并处理消息了。
return len;
}
Netlink 内核实现分析 3的更多相关文章
- Netlink 内核实现分析（二）：通信
在前一篇博文<Netlink 内核实现分析(一):创建>中已经较为具体的分析了Linux内核netlink子系统的初始化流程.内核netlink套接字的创建.应用层netlink套接字的创 ...
- Netlink 内核实现分析 2
netlink 应用层如何创建socket 应用层通过socket()系统调用创建Netlink套接字,socket系统调用的第一个参数可以是AF_NETLINK或PF_NETLINK(在Linux系 ...
- Netlink 内核实现分析 1
Netlink 是一种IPC(Inter Process Commumicate)机制,它是一种用于内核与用户空间通信的机制,在一般情况下,用户态和内核态通信会使用传统的Ioctl.sysfs属性文件 ...
- Netlink 内核实现分析 4
netlink 库函数: http://www.infradead.org/~tgr/libnl/doc/core.html#core_netlink_fundamentals #define NET ...
- MINIX3 内核时钟分析
MINIX3 内核时钟分析 4.1 内核时钟概要 先想想为什么 OS 需要时钟?时钟是异步的一个非常重要的标志,设想一下,如 果我们的应用程序需要在多少秒后将触发某个程序或者进程,我们该怎么做到? ...
- mkimage工具 加载地址和入口地址 内核启动分析
第三章第二节 mkimage工具制作Linux内核的压缩镜像文件,需要使用到mkimage工具.mkimage这个工具位于u-boot-2013. 04中的tools目录下,它可以用来制作不压缩或者压 ...
- 第3阶段——内核启动分析之start_kernel初始化函数(5)
内核启动分析之start_kernel初始化函数(init/main.c) stext函数启动内核后,就开始进入start_kernel初始化各个函数, 下面只是浅尝辄止的描述一下函数的功能,很多函数 ...
- 几个常用内核函数（《Windows内核情景分析》）
参考:<Windows内核情景分析> 0x01 ObReferenceObjectByHandle 这个函数从句柄得到对应的内核对象,并递增其引用计数. NTSTATUS ObRefer ...
- [1]windows 内核情景分析---说明
本文说明:这一系列文章(笔记)是在看雪里面下载word文档,现转帖出来,希望更多的人能看到并分享,感谢原作者的分享精神. 说明 本文结合<Windows内核情景分析>(毛德操著).< ...
随机推荐
- DM9000裸机驱动程序设计
对于任何一个硬件模块的设计,首先第一步都是要先了解硬件本身后,再开始程序的软件设计.而由于DM9000的芯片文档内容很多,要驱动好网卡,需要很长时间,特别对于新手比较困难,所以可以参考linux内核代 ...
- 从面试角度学完 Kafka
Kafka 是一个优秀的分布式消息中间件,许多系统中都会使用到 Kafka 来做消息通信.对分布式消息系统的了解和使用几乎成为一个后台开发人员必备的技能.今天码哥字节就从常见的 Kafka 面试题入手 ...
- 3.QOpenGLWidget-通过着色器来渲染渐变三角形
在上章2.通过QOpenGLWidget绘制三角形,我们学习绘制三角形还是单色的,本章将为三角形每个顶点着色. 1.着色器描述 着色器的开头总是要声明版本,接着是输入和输出变量.uniform和m ...
- JavaWeb学习笔记（六）jsp
第六章.jsp 1.什么是jsp jsp:java server pages,java的服务器页面 作用:代替Servlet回传HTML页面的数据 因为Servlet程序回传HTML页面的数据很繁琐, ...
- vue中上拉加载数据的实现
获取屏幕高度来判断数据的加载 效果是这样的
- Ubuntu 18.04 LTS IP 地址设置
和之前的版本不太一样, Ubuntu 18.04 的 ip地址设置是用netplan管理的 配置文件在: /etc/netplan/50-cloud-init.yaml 示例文件如下: # T ...
- 基于node.js的爬虫框架 node-crawler简单尝试
百度爬虫这个词语,一般出现的都是python相关的资料. py也有很多爬虫框架,比如scrapy,Portia,Crawley等. 之前我个人更喜欢用C#做爬虫. 随着对nodejs的熟悉.发现做这种 ...
- linux启动oracle服务 和监听
(1) su - oracle 切换成oracle 用户 (2)sqlplus / as sysdba (3)startup: (4)quit:退出sql模式 exit 退出oracle用户 (5)l ...
- 关于oracle监听程序的相关问题及解决方法
1.查看监听程序是否启动 打开cmd窗口,cmd用管理员运行,否则无法执行启动与停止监听命令 lsnrctl status查看运行状态 lsnrctl stop停止监听 lsnrctl start启动 ...
- 盘点.NET JIT在Release下由循环体优化所产生的不确定性Bug
盘点在Release下由循环体优化所产生的不确定性Bug 在这篇文章中,我将介绍一些在测试环境(DEBUG)下正常,但在生产环境(Release)下却会出现的一些让人难以捉摸的Bug. 如果你对开源技 ...