Linux网络栈协议无关层--BSD socket
一. 从socket api看协议无关层
前面的系列已经说了系统调用接口层，在应用层使用socket api，填充对应的参数，就能创建出想要使用的socket类型。这个过程就是协议无关层完成的。简单的说过程就是：根据参数，匹配注册的协议族，使用对应的协议。接下来重点分析几个socket api的BSD无关层实现，来更深一步理解这个问题。
1.1 socket()
在应用层调用socket()后，就会触发sys_socket系统调用。那我们就去看看在这个系统调用函数中都做了什么事：net/socket.c文件
SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
int retval;
struct socket *sock;
int flags;
/* Check the SOCK_* constants for consistency. */
BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
flags = type & ~SOCK_TYPE_MASK;
if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
return -EINVAL;
type &= SOCK_TYPE_MASK;
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
retval = sock_create(family, type, protocol, &sock);
if (retval < 0)
goto out;
retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
if (retval < 0)
goto out_release;
out:
/* It may be already another descriptor 8) Not kernel problem. */
return retval;
out_release:
sock_release(sock);
return retval
}
省略前面的检查，实际上只有2个函数：sock_create()和sock_map_fd()。接着看sock_create(),sock_create()->__sock_create().
security_socket_create()这是创建安全的socket，没定义的话，就是空操作。sock_alloc()创建了一个struct socket，注意这个结构，后面还有其他的很相似的结构。struct socket就是BSD层维护的socket对象。因为UNIX秉承一切皆文件的思想，所以，这个socket对象也是和inode结构一起创建并绑定到一起的。创建之后，填充socket的类型：sock->type = type;- 根据协议族和类型，创建对应类型的socket(struct sock)。如下代码有删减。
pf = rcu_dereference(net_families[family]);
err = pf->create(net, sock, protocol);
if (err < 0)
goto out_module_put;
pf->create()到这里才是真正的无关层体现的地方，即根据协议族和类型，创建socket。但这里的socket实际指的是struct sock结构，这个结构贯穿了整个协议栈。那它和struct socket有啥区别和联系呢？这里先卖个关子，到数据结构那节再具体说。现在接着说pf->create,pf是从net_families[family]中取出来的，pf的结构如下：
struct net_proto_family {
int family;
int (*create)(struct net *net, struct socket *sock, int protocol);
struct module *owner;
};
这实际上是代表了一个协议族，每个协议族有自己的create函数，如inet就是inet_create()。那肯定要问了，那这些协议族是什么时候注册的呢？答案是在协议族初始化的时候。还拿inet族举例，就是在inet_init()时，再往上追就是fs_initcall(inet_init);。
我们看到这么一句话：
(void)sock_register(&inet_family_ops);
你瞧，inet_family_ops（struct net_proto_family)把自己注册进"活着"的协议族列表，仿佛在说：“hi,BSD,我INET协议族来报道啦！”
int sock_register(const struct net_proto_family *ops)
{
int err;
if (ops->family >= NPROTO) {
printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
NPROTO);
return -ENOBUFS;
}
spin_lock(&net_family_lock);
if (net_families[ops->family])
err = -EEXIST;
else {
net_families[ops->family] = ops;
err = 0;
}
spin_unlock(&net_family_lock);
printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
return err;
}
看那net_families[ops->family]不就是前面提到的么？这就是“活着”的协议族的集合。
4.inet_create()，创建socket。
list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
err = 0;
/* Check the non-wild match. */
if (protocol == answer->protocol) {
if (protocol != IPPROTO_IP)
break;
} else {
/* Check for the two wild cases. */
if (IPPROTO_IP == protocol) {
protocol = answer->protocol;
break;
}
if (IPPROTO_IP == answer->protocol)
break;
}
err = -EPROTONOSUPPORT;
}
先根据sock->type找到要创建的socket的模板，模板是什么，怎么来的呢？对于inet协议族而言，模板就是都在inetsw这个链表里存着啦，自然会想到是不是也是在inet_init()时添加进去的呢？没错，我们回过头去看：
for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
INIT_LIST_HEAD(r);
for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
inet_register_protosw(q);
到这里不得不说一下socket类型这个东西，站在BSD的角度，抽象了几种socket类型出来:
enum sock_type {
SOCK_STREAM = 1,
SOCK_DGRAM = 2,
SOCK_RAW = 3,
SOCK_RDM = 4,
SOCK_SEQPACKET = 5,
SOCK_DCCP = 6,
SOCK_PACKET = 10,
};
对于具体的协议族怎么实现这些对应的类型，BSD是不关心的，比如在inet协议族，tcp对应的是SOCK_STREAM类型，udp对应的是SOCK_DGRAM等。对于其他的协议族而言，要对应起自己的协议。再看上面的两句，初始化了每种inet每种socket类型的链表。然后inet_register_protosw()把inetsw_array数组中对应的类型注册到inetsw对应类型的链表中。这个inetsw_array数组其实就是每个协议族连接BSD和自己的传输层的桥梁。就拿其中一个元素来看：
{
.type = SOCK_STREAM,
.protocol = IPPROTO_TCP,
.prot = &tcp_prot,
.ops = &inet_stream_ops,
.capability = -1,
.no_check = 0,
.flags = INET_PROTOSW_PERMANENT |
INET_PROTOSW_ICSK,
},
就是说，如果BSD要创建SOCK_STREAM类型的套接字，那么就对应于inet族的tcp协议，自然对于BSD层的操作，也有抽象出来的操作集，就是struct proto_ops表示。那么为什么还会有一个struct ops的结构呢？很明显，这个是用于inet层的操作集，上文提到,每一种类型的socket都有自己的协议链表，也就是对于inet的流式套接字而言，也可能有多种协议（当然，现在只注册了tcp一种）。
接着刚才的创建往下看，找到对应的类型后，就填充其中的成员：
sock->ops = answer->ops;
answer_prot = answer->prot;
answer_no_check = answer->no_check;
answer_flags = answer->flags;
然后就分配了struct sock对象和struct inet_sock对象,
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);。初始化sock对象和inet_sock对象。最后调用sock对象的init。主要是针对tcp和raw的，需要初始化，udp就没有init操作。
if (sk->sk_prot->init) {
err = sk->sk_prot->init(sk);
if (err)
sk_common_release(sk);
}
5.映射socket到文件描述符。在完成socket创建后，就把这个socket和一个文件描述符fd关联起来，以后就可以直接用读写文件的方式访问这个socket了。sock_map_fd()。这一步操作过后，socket创建就算完成了。
1.2 sendto()
1.3 recvfrom()
这两个接口的介绍，就放到下一篇中进行，选着两个主要就是想说一下数据包从内核态到用户态的过程。本篇已经很长了，原谅我先挖个坑吧 😃
二. 相关数据结构
-
struct socket与struct sock与struct inet_sock
这两个数据结构实际上是分工协作的，不单纯是分层的关系。struct socket代表的是BSD层上对所有socket的抽象，而struct sock代表的是每个协议族对socket的抽象。这是两个很重要的层次关系，我们说协议无关层下面就是传输层，但并不是说sock是对传输层的socket的抽象，所以，无论是对BSD层的抽象还是对每个协议族的抽象，都应该属于协议无关层，只是对协议无关层两个方面的抽象。这时候就有疑问了：既然都属于协议无关层的抽象，为什么不合并这两个结构呢？因为struct socket是使用inode关联的，我们也看到struct sock结构庞大，如果把struct sock合并到struct socket中，岂不是建每个文件inode都需要占用很大空间咯？所以，把套接字中的跟文件有关的部分拿出来就是struct socket，而把剩余的跟socket数据有关的都放到struct sock中。而struct inet_sock则是为了更加方便使用inet族，在struct sock的基础上，又封装而成的。 -
struct proto_ops与struct proto
自然，BSD层既然抽象了socket,就会有抽象的操作集，struct proto_ops就是抽象的操作集，它操作的就是协议族；struct proto就是对协议族层面的操作集的抽象，它操作的就是实际的传输层协议。这个可以跟上面的struct socket和struct sock进行类比。
这些结构共同实现了网络栈协议无关层。所以，可以看到，这一篇没有说到具体传输层的东西，比如tcp，udp操作等。
三. 文件分布
协议无关层的文件分布主要在:
net/socket.cnet/core/sock.c
四. 小结
linux网络栈非常庞大，包罗万象，支持各种各样的协议，为了能够让应用层简单方便的使用socket，linux提供了抽象层，把跟协议无关的东西拿出来，让应用层仅仅提供参数，就能在适配合适的协议族和使用的协议。大大减小了应用层的复杂度。
