Linux内核中netlink协议族的实现(上)

本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。
msn: [e-mail]
来源：http://yfydz.cublog.cn

1. 前言

netlink协议族是Linux内核网络部分的一个固定部分, 一旦在内核配置中选了网络支持就自动带了而不能单独去掉。

netlink的实现源码在net/netlink目录下，主要是net/netlink/af_netlink.c文件。

以下内核代码版本为2.6.19.2, 如无特别说明代码取自net/netlink/af_netlink.c。

2. 数据结构

netlink套接口结构:

/* net/netlink/af_netlink.c */

struct netlink_sock {
/* struct sock has to be the first member of netlink_sock */
struct socksk;
u32pid; // 自己的pid, 通常是0
u32dst_pid; // 对方的pid
u32dst_group; // 对方的组
u32flags;
u32subscriptions;
u32ngroups; // 多播组数量
unsigned long*groups; // 多播组号
unsigned longstate;
wait_queue_head_twait; // 等待队列,用于处理接收发送包时的top half
struct netlink_callback*cb; // 回调结构,包含回调函数
spinlock_tcb_lock;
void(*data_ready)(struct sock *sk, int bytes); // 数据到达时
//的操作, netlink可有不同类型, 如ROUTE, FIREWALL, ARPD等, //每种类型都自己定义的data_ready处理
struct module*module;
};

这个结构先是包含一个标准的struct sock结构,后面又跟和netlink相关的特有相关数据,内核中其他协议的sock也是类似定义的, 注意sock结构必须放在第一位,这是为了可以直接将sock的指针转为netlink_sock的指针。

netlink sock的表:

struct netlink_table {
struct nl_pid_hash hash; // 根据pid进行HASH的netlink sock链表, 相当于客户端链表
struct hlist_head mc_list; // 多播的sock链表
unsigned long *listeners; // 监听者标志
unsigned int nl_nonroot;
unsigned int groups; // 每个netlink的协议类型可以定义多个组, 8的倍数,最小是32
struct module *module;
int registered;
};

最大可有MAX_LINKS(32)个表，处理不同协议类型的netlink套接口, 注意由于是自身的通信, 本机同时作为服务器和客户端, 服务端需要一个套接口对应, 每个客户端也要有一个套接口对应, 多个客户端的套接口形成一个链表.

struct nl_pid_hash {
struct hlist_head *table; // 链表节点
unsigned long rehash_time; // 重新计算HASH的时间间隔

unsigned int mask;
unsigned int shift;

unsigned int entries; // 链表节点数
unsigned int max_shift; // 最大幂值

u32 rnd; // 随机数
};

其他和netlink数据相关的数据结构在include/linux/netlink.h中定义, 不过这些结构更多用在各具体的netlink对象的实现中, 在基本netlink套接口中到是用得不多。

3. af_netlink协议初始化

static int __init netlink_proto_init(void)
{
struct sk_buff *dummy_skb;
int i;
unsigned long max;
unsigned int order;

// 登记netlink_proto结构, 该结构定义如下:
// static struct proto netlink_proto = {
// .name = "NETLINK",
// .owner = THIS_MODULE,
// .obj_size = sizeof(struct netlink_sock),
// };
// 最后一个参数为0, 表示不进行slab的分配, 只是简单的将netlink_proto结构
// 挂接到系统的网络协议链表中,这个结构最主要是告知了netlink sock结构的大小
int err = proto_register(&netlink_proto, 0);

if (err != 0)
goto out;

BUILD_BUG_ON(sizeof(struct netlink_skb_parms) > sizeof(dummy_skb->cb));

// 分配MAX_LINKS个netlink表结构
nl_table = kcalloc(MAX_LINKS, sizeof(*nl_table), GFP_KERNEL);
if (!nl_table)
goto panic;

// 以下根据系统内存大小计算最大链表元素个数
// PAGE_SHIFT是每页大小的2的幂,对i386是12,即每页是4K,2^12
// 对于128M内存的机器,max计算值是(128*1024) >> (21-12) = 256
// 对于64M内存的机器,max计算值是(64*1024) >> (23-12) = 32
if (num_physpages >= (128 * 1024))
max = num_physpages >> (21 - PAGE_SHIFT);
else
max = num_physpages >> (23 - PAGE_SHIFT);

// 根据max再和PAGE_SHIFT计算总内存空间相应的幂值order
order = get_bitmask_order(max) - 1 + PAGE_SHIFT;
// max是最大节点数
max = (1UL << order) / sizeof(struct hlist_head);
// order是max对于2的幂数
order = get_bitmask_order(max > UINT_MAX ? UINT_MAX : max) - 1;

for (i = 0; i < MAX_LINKS; i++) {
struct nl_pid_hash *hash = &nl_table[i].hash;
// 为netlink的每个协议类型分配HASH表链表头
hash->table = nl_pid_hash_alloc(1 * sizeof(*hash->table));
if (!hash->table) {
while (i-- > 0)
nl_pid_hash_free(nl_table[i].hash.table,
1 * sizeof(*hash->table));
kfree(nl_table);
goto panic;
}
// 初始化HASH表参数
memset(hash->table, 0, 1 * sizeof(*hash->table));
// 最大幂数
hash->max_shift = order;
hash->shift = 0;
hash->mask = 0;
hash->rehash_time = jiffies;
}
// 登记netlink协议族的的操作结构
sock_register(&netlink_family_ops);
#ifdef CONFIG_PROC_FS
proc_net_fops_create("netlink", 0, &netlink_seq_fops);
#endif
/* The netlink device handler may be needed early. */
// 初始化路由netlink
rtnetlink_init();
out:
return err;
panic:
panic("netlink_init: Cannot allocate nl_table/n");
}

core_initcall(netlink_proto_init);

4. 建立netlink套接口

4.1 建立对应客户端的套接口

// netlink协议族操作, 在用户程序使用socket打开netlink类型的socket时调用,
// 相应的create函数在__sock_create(net/socket.c)函数中调用:
static struct net_proto_family netlink_family_ops = {
.family = PF_NETLINK,
.create = netlink_create,
.owner= THIS_MODULE,/* for consistency 8) */
};

// 在用户空间每次打开netlink socket时都会调用此函数:
static int netlink_create(struct socket *sock, int protocol)
{
struct module *module = NULL;
struct netlink_sock *nlk;
unsigned int groups;
int err = 0;
// sock状态初始化
sock->state = SS_UNCONNECTED;

// 对netlink sock的类型和协议(实际是netlink_family类型)限制检查
if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
return -ESOCKTNOSUPPORT;

if (protocol<0 || protocol >= MAX_LINKS)
return -EPROTONOSUPPORT;

netlink_lock_table();
#ifdef CONFIG_KMOD
// 如果相应的netlink协议是模块又没有加载的话先加载该模块
if (!nl_table[protocol].registered) {
netlink_unlock_table();
request_module("net-pf-%d-proto-%d", PF_NETLINK, protocol);
netlink_lock_table();
}
#endif
if (nl_table[protocol].registered &&
try_module_get(nl_table[protocol].module))
module = nl_table[protocol].module;

// groups这个值在函数后面也没见用上, 这句没意义
groups = nl_table[protocol].groups;
netlink_unlock_table();

// 真正的建立netlink sock的函数
if ((err = __netlink_create(sock, protocol)) < 0)
goto out_module;

nlk = nlk_sk(sock->sk);
nlk->module = module;
out:
return err;

out_module:
module_put(module);
goto out;
}

// 基本函数
static int __netlink_create(struct socket *sock, int protocol)
{
struct sock *sk;
struct netlink_sock *nlk;

// netlink sock的基本操作
sock->ops = &netlink_ops;
// 分配sock结构, 通过netlink_proto中的obj_size指出了netlink sock的大小
sk = sk_alloc(PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
if (!sk)
return -ENOMEM;
// 初始化sock基本数据, 将sock和socket关联起来
sock_init_data(sock, sk);
// 将普通sock转为netlink sock,实际只是重新定义的一下指针类型,指针本身值不变
nlk = nlk_sk(sk);
// 初始化sock的锁
spin_lock_init(&nlk->cb_lock);
// 初始化等待队列
init_waitqueue_head(&nlk->wait);
// sock的析构函数,释放接收队列中的skb数据包
sk->sk_destruct = netlink_sock_destruct;
sk->sk_protocol = protocol;
// 注意这里没有重新定义sk的sk_data_ready函数
// 在sock_init_data()函数中将sk_data_ready定义为sock_def_readable()函数
return 0;
}

用户空间使用socket(2)系统调用打开netlink类型的套接口时, 在内核中会调用sys_sock()函数, 然后是调用__sock_create()函数, 在其中调用netlink协议族的create()函数, 即netlink_create()函数.

4.2 建立服务器端的套接口

以前也介绍过另一个建立netlink sock的函数netlink_kernel_create, 一般是在netlink的各种协议类型模块初始化时调用的, 而不是socket系统调用时调用的, 每个netlink协议初始化是只调用一次, 建立一个内核中的netlink接口, 相当于服务器, 其中也调用了__netlink_create()函数:

/*
*We export these functions to other modules. They provide a
*complete set of kernel non-blocking support for message
*queueing.
*/

struct sock *
netlink_kernel_create(int unit, unsigned int groups,
void (*input)(struct sock *sk, int len),
struct module *module)
{
struct socket *sock;
struct sock *sk;
struct netlink_sock *nlk;
unsigned long *listeners = NULL;

BUG_ON(!nl_table);

if (unit<0 || unit>=MAX_LINKS)
return NULL;

// 这里的lite表示只是简单分配一个socket,没有真正初始化
if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
return NULL;

// 用这个lite sock再建立netlink sock
if (__netlink_create(sock, unit) < 0)
goto out_sock_release;

if (groups < 32)
groups = 32;
// listerns是个位图对应groups中每个元素
listeners = kzalloc(NLGRPSZ(groups), GFP_KERNEL);
if (!listeners)
goto out_sock_release;

sk = sock->sk;
// 重新定义了sk_data_ready函数
sk->sk_data_ready = netlink_data_ready;
// 这个是相应的各netlink协议数据处理函数
if (input)
nlk_sk(sk)->data_ready = input;

if (netlink_insert(sk, 0))
goto out_sock_release;

nlk = nlk_sk(sk);
nlk->flags |= NETLINK_KERNEL_SOCKET;

netlink_table_grab();
// 注册到相应unit的netlink协议表中
nl_table[unit].groups = groups;
nl_table[unit].listeners = listeners;
nl_table[unit].module = module;
// 该标志表示该项被登记
nl_table[unit].registered = 1;
netlink_table_ungrab();

return sk;

out_sock_release:
kfree(listeners);
sock_release(sock);
return NULL;
}

5. netlink套接口的操作

在__netlink_create函数中定义了netlink套接口的操作结构为netlink_ops:
sock->ops = &netlink_ops;

该结构定义如下:

static const struct proto_ops netlink_ops = {
.family =PF_NETLINK,
.owner =THIS_MODULE,
.release =netlink_release,
.bind =netlink_bind,
.connect =netlink_connect,
.socketpair =sock_no_socketpair, // 无定义
.accept =sock_no_accept, // 无定义
.getname =netlink_getname,
.poll =datagram_poll,
.ioctl =sock_no_ioctl, // 无定义
.listen =sock_no_listen, // 无定义
.shutdown =sock_no_shutdown, // 无定义
.setsockopt =netlink_setsockopt,
.getsockopt =netlink_getsockopt,
.sendmsg =netlink_sendmsg,
.recvmsg =netlink_recvmsg,
.mmap =sock_no_mmap, // 无定义
.sendpage =sock_no_sendpage, // 无定义
};

5.1 释放

在close(2)时调用

static int netlink_release(struct socket *sock)
{
struct sock *sk = sock->sk;
struct netlink_sock *nlk;

if (!sk)
return 0;

// 将套接口sk从系统sk链表和绑定链表中断开
netlink_remove(sk);
nlk = nlk_sk(sk);

spin_lock(&nlk->cb_lock);
if (nlk->cb) {
// 释放netlink控制块处理
if (nlk->cb->done)
nlk->cb->done(nlk->cb);
netlink_destroy_callback(nlk->cb);
nlk->cb = NULL;
}
spin_unlock(&nlk->cb_lock);

/* OK. Socket is unlinked, and, therefore,
no new packets will arrive */
// 设置sk状态为SOCK_DEAD, 断开sock和sk的互指
sock_orphan(sk);
sock->sk = NULL;
// 唤醒所有等待队列
wake_up_interruptible_all(&nlk->wait);
// 清空写队列
skb_queue_purge(&sk->sk_write_queue);

if (nlk->pid && !nlk->subscriptions) {
// 发送释放通知
struct netlink_notify n = {
.protocol = sk->sk_protocol,
.pid = nlk->pid,
};
atomic_notifier_call_chain(&netlink_chain,
NETLINK_URELEASE, &n);
}

// 减少模块计数
if (nlk->module)
module_put(nlk->module);

// 相当于加锁
netlink_table_grab();

if (nlk->flags & NETLINK_KERNEL_SOCKET) {
// 释放内核中的netlink服务器端
kfree(nl_table[sk->sk_protocol].listeners);
nl_table[sk->sk_protocol].module = NULL;
nl_table[sk->sk_protocol].registered = 0;
} else if (nlk->subscriptions)
netlink_update_listeners(sk);
// 相当于解锁
netlink_table_ungrab();
// 释放该netlink sock的多播组
kfree(nlk->groups);
nlk->groups = NULL;

// 释放sock
sock_put(sk);
return 0;
}

5.2 绑定bind

绑定通常是针对服务端

static int netlink_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
struct sock *sk = sock->sk;
struct netlink_sock *nlk = nlk_sk(sk);
struct sockaddr_nl *nladdr = (struct sockaddr_nl *)addr;
int err;
// 检查一下地址的协议族是否为AF_NETLINK
if (nladdr->nl_family != AF_NETLINK)
return -EINVAL;

/* Only superuser is allowed to listen multicasts */
if (nladdr->nl_groups) {
// 指定了多播组, 这是需要root权限
if (!netlink_capable(sock, NL_NONROOT_RECV))
return -EPERM;
if (nlk->groups == NULL) {
// 分配多播组空间
err = netlink_alloc_groups(sk);
if (err)
return err;
}
}

if (nlk->pid) {
// 如果sock的pid非0, 检查是否匹配在nladdr地址结构中指定的pid
if (nladdr->nl_pid != nlk->pid)
return -EINVAL;
} else {
// sock的pid为0, 根据nladdr是否指定pid来执行插入或
err = nladdr->nl_pid ?
netlink_insert(sk, nladdr->nl_pid) :
netlink_autobind(sock);
if (err)
return err;
}

// 非多播情况时就可以返回成功了
if (!nladdr->nl_groups && (nlk->groups == NULL || !(u32)nlk->groups[0]))
return 0;

netlink_table_grab();
// 多播情况下更新sock参数
netlink_update_subscriptions(sk, nlk->subscriptions +
hweight32(nladdr->nl_groups) -
hweight32(nlk->groups[0]));
nlk->groups[0] = (nlk->groups[0] & ~0xffffffffUL) | nladdr->nl_groups;
netlink_update_listeners(sk);
netlink_table_ungrab();

return 0;
}

// 根据pid插入
static int netlink_insert(struct sock *sk, u32 pid)
{
// netlink相应协议的HASH结构
struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
struct hlist_head *head;
// 缺省错误为地址已经被使用
int err = -EADDRINUSE;
struct sock *osk;
struct hlist_node *node;
int len;

netlink_table_grab();
// 根据pid查找相应HASH链表头
head = nl_pid_hashfn(hash, pid);
len = 0;
// 检查pid是否已经在链表中, 有则失败
sk_for_each(osk, node, head) {
if (nlk_sk(osk)->pid == pid)
break;
len++;
}
if (node)
goto err;

// 缺省错误改为系统忙
err = -EBUSY;
// 如果sock的pid不为0, 错误, 只有pid为0的sock才能执行该函数
// sock的pid不为0时不会再进行insert操作了
if (nlk_sk(sk)->pid)
goto err;

// 缺省错误改为无内存空间
err = -ENOMEM;
if (BITS_PER_LONG > 32 && unlikely(hash->entries >= UINT_MAX))
goto err;

// 如果链表不为空而且链表长度数量过长,会调整HASH表,重新获取HASH链表头
// 不过这种情况很少发生
if (len && nl_pid_hash_dilute(hash, len))
head = nl_pid_hashfn(hash, pid);
hash->entries++;
// 将pid赋值给sock的pid参数
nlk_sk(sk)->pid = pid;
// 将sock节点添加进HASH链表
sk_add_node(sk, head);
err = 0;

err:
netlink_table_ungrab();
return err;
}

// 未指定pid时的自动绑定
// 实际是选一个没用过的pid后再进行插入操作
static int netlink_autobind(struct socket *sock)
{
// 从socket找到sock
struct sock *sk = sock->sk;
// netlink相应协议的HASH结构
struct nl_pid_hash *hash = &nl_table[sk->sk_protocol].hash;
struct hlist_head *head;
struct sock *osk;
struct hlist_node *node;
// pid取为当前进程的组ID
s32 pid = current->tgid;
int err;
// 有符号32位数
static s32 rover = -4097;

retry:
cond_resched();
netlink_table_grab();
// 找合适的HASH链表头
head = nl_pid_hashfn(hash, pid);
sk_for_each(osk, node, head) {
// 查找链表中是否已经有该pid
if (nlk_sk(osk)->pid == pid) {
// 存在, 则更新pid, 重新检查, 注意这时的pid是个负数
/* Bind collision, search negative pid values. */
pid = rover--;
if (rover > -4097)
rover = -4097;
netlink_table_ungrab();
goto retry;
}
}
netlink_table_ungrab();

// 此时的pid是一个负数转换为无符号32位数, 将是一个非常大的数
// 执行正常的pid插入
err = netlink_insert(sk, pid);
if (err == -EADDRINUSE)
goto retry;

/* If 2 threads race to autobind, that is fine. */
if (err == -EBUSY)
err = 0;

return err;
}

// 更新subscriotions
static void
netlink_update_subscriptions(struct sock *sk, unsigned int subscriptions)
{
struct netlink_sock *nlk = nlk_sk(sk);

if (nlk->subscriptions && !subscriptions)
__sk_del_bind_node(sk);
else if (!nlk->subscriptions && subscriptions)
sk_add_bind_node(sk, &nl_table[sk->sk_protocol].mc_list);
nlk->subscriptions = subscriptions;
}

// 更新listeners
static void
netlink_update_listeners(struct sock *sk)
{
struct netlink_table *tbl = &nl_table[sk->sk_protocol];
struct hlist_node *node;
unsigned long mask;
unsigned int i;

for (i = 0; i < NLGRPSZ(tbl->groups)/sizeof(unsigned long); i++) {
mask = 0;
// 遍历多播链表生成多播组的掩码
sk_for_each_bound(sk, node, &tbl->mc_list)
mask |= nlk_sk(sk)->groups[i];
tbl->listeners[i] = mask;
}
/* this function is only called with the netlink table "grabbed", which
* makes sure updates are visible before bind or setsockopt return. */
}