netlink 与 socket

netlink对socket函数的实现(v2.6.18)
应用层调用：
skfd = socket(PF_NETLINK, SOCK_RAW, NL_IMP2);
/net/socket.c:
中有一个全局变量,它存储协议族：
static struct net_proto_family *net_families[NPROTO];
 struct net_proto_family {
         int             family;
         int             (*create)(struct socket *sock, int protocol);  （注1）         
         short           authentication;
         short           encryption;
         short           encrypt_net;
         struct module   *owner;
 };




系统调用：
asmlinkage long sys_socket(int family, int type, int protocol)
继续调用：
int sock_create(int family, int type, int protocol, struct socket **res)
继续调用：
static int __sock_create(int family, int type, int protocol, struct socket **res, int kern)
其中有一句：
if ((err = net_families[family]->create(sock, protocol)) < 0) {
               sock->ops = NULL;
               goto out_module_put;
}
说明它是调用协议族规定的create回调函数（见注1）
那么，我们需要知道netlink协议的协议族（ net_proto_family）是什么时候进入全局变量net_families里的，继续向下看，发现有一个函数
int sock_register(struct net_proto_family *ops)
{
int err;
if (ops->family >= NPROTO) {
printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
return -ENOBUFS;
}
net_family_write_lock();
err = -EEXIST;
if (net_families[ops->family] == NULL) {        (注2)
net_families[ops->family]=ops;
err = 0;
}
net_family_write_unlock();
printk(KERN_INFO "NET: Registered protocol family %d\n",
ops->family);
return err;
}
系统是在这个函数中给全局变量net_families赋值的（见注2）。那netlink一定有调用 sock_register函数，搜源代码。。。。
发现在/net/netlink/af_netlink.c中有一个函数static int __init netlink_proto_init(void)。
此函数中调用了注册协议族的函数:
 sock_register(&netlink_family_ops);
而netlink_family_ops是netlink的一个全局变量：
static struct net_proto_family netlink_family_ops = {
       .family = PF_NETLINK,
       .create = netlink_create,（注3）
       .owner  = THIS_MODULE,  /* for consistency 8) */
};
由此可见，socket最终是调用netlink模块的netlink_create回调来创建netlink的“特殊”socket的（见注3）


struct socket {
       socket_state            state;
       unsigned long           flags;
       const struct proto_ops  *ops;
       struct fasync_struct    *fasync_list;
       struct file             *file;
       struct sock             *sk;
       wait_queue_head_t       wait;
       short                   type;
};


struct netlink_sock {
       /* struct sock has to be the first member of netlink_sock */
   struct sock             sk;
       u32                     pid;
       u32                     dst_pid;
       u32                     dst_group;
       u32                     flags;
       u32                     subscriptions;
       u32                     ngroups;
       unsigned long           *groups;
       unsigned long           state;
       wait_queue_head_t       wait;
       struct netlink_callback *cb;
       spinlock_t              cb_lock;
       void                    (*data_ready)(struct sock *sk, int bytes);
       struct module           *module;
};




由以上两个结构可见 netlink_socket的第一个元素就是系统标准的socket，它是对系统标准socket的一个封装，这样也方便由netlink_sock强转成标准socket，保持的兼容性








再往后，netlink _create函数会调用内部函数 __netlink_create;
static int __netlink_create(struct socket *sock, int protocol)
 {
         struct sock *sk;
         struct netlink_sock *nlk;
 
         sock->ops = &netlink_ops;
 
         sk = sk_alloc(PF_NETLINK, GFP_KERNEL, &netlink_proto, 1);
         if (!sk)
                 return -ENOMEM;
 
         sock_init_data(sock, sk);
 
         nlk = nlk_sk(sk);
         spin_lock_init(&nlk->cb_lock);
         init_waitqueue_head(&nlk->wait);
 
         sk->sk_destruct = netlink_sock_destruct;
         sk->sk_protocol = protocol;
         return 0;
 }
 此函数有一句 sock->ops = &netlink_ops; 实际上netlink_ops是netlink模块的一个全局常量，它表示着socket所关联的一系列操作
 
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,
};




二、关于bind
 
应用层调用 bind(skfd, (struct sockaddr*)&local, sizeof(local));
系统调用：/net/socket.c
asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
{
        struct socket *sock;
        char address[MAX_SOCK_ADDR];
        int err, fput_needed;




        if((sock = sockfd_lookup_light(fd, &err, &fput_needed))!=NULL)     //找到fd对应的的socket
        {
                if((err=move_addr_to_kernel(umyaddr,addrlen,address))>=0) {
                        err = security_socket_bind(sock, (struct sockaddr *)address, addrlen);
                        if (!err)
                                err = sock->ops->bind(sock,(struct sockaddr *)address, addrlen);  //将address 和socket绑定
                }
                fput_light(sock->file, fput_needed);
        }                       
        return err;
}




所以  err = sock->ops->bind(sock,(struct sockaddr *)address, addrlen); 实质上是调用netlink的bind函数。此时标准的addr被转成netlink的地址格式
并通过 netlink_update_subscriptions(sk, nlk->subscriptions + hweight32(nladdr->nl_groups) - hweight32(nlk->groups[0]));来将相关信息组织起来（详情以后分析）




总结
其它函数的实现与此类似也是最终转到了netlink模块进行调用。