Linux协议栈代码阅读笔记（一）
（基于linux-2.6.21.7）
（一）用户态通过诸如下面的C库函数访问协议栈服务
int socket(int domain, int type, int protocol);
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
……
（二）上述C库函数如何与内核交互
C库代码准备好相应的工作后（例如，设置系统调用号啦、参数构造啦、栈啦、寄存器设置啦），通过系统调用指令，进入内核态。从内核返回后，C库函数再做相应的善后工作，然后将结果返回给用户程序。
这部分代码，不同架构的处理器，有不同的实现。
可以参考Glibc的源码。
下面以X86为例，简要描述一下这个过程。
另外，后续的内容，如无特殊说明，均是针对X86架构。
对于X86架构，一般是通过“int $0x80”指令进入内核，即触发128号中断。
内核中断向量表的定义如下(源码文件archi386kernel Traps.c)：
struct desc_struct idt_table[256] __attribute__((__section__(".data.idt"))) = { {0, 0}, };
函数trap_init(源码文件archi386kernel Traps.c)对此表进行了初始化。
其中，对128号中断的初始化方式为：
set_system_gate(SYSCALL_VECTOR,&system_call);
SYSCALL_VECTOR宏的值为0x80，即128。
因此，128号中断，即对应中断向量表的第128个条目，其中断服务程序为system_call这段代码。
system_call这段代码，是用汇编实现的。
其代码在archi386kernelentry.S中。
这个代码，主要是根据系统调用号，索引系统调用表中的一个条目进行执行。
（三）内核态如何处理用户的网络通讯请求
上一步，C库发起了系统调用，进入了内核128号中断，即系统调用软中断。
128号中断处理程序，根据系统调用号，进入系统调用表的相应表目。系统调用表如下，每个表目是一个函数指针。(源码文件：archi386kernel syscall_table.S)
ENTRY(sys_call_table)
.long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */
.long sys_exit
.long sys_fork
.long sys_read
.long sys_write
.long sys_open /* 5 */
.long sys_close
.long sys_waitpid
.long sys_creat
.long sys_link
.long sys_unlink /* 10 */
.long sys_ni_syscall /* old lock syscall holder */
…
.long sys_statfs
.long sys_fstatfs /* 100 */
.long sys_ioperm
.long sys_socketcall
.long sys_syslog
…
.long sys_tee /* 315 */
.long sys_vmsplice
.long sys_move_pages
.long sys_getcpu
.long sys_epoll_pwait
对于上述的几个socket库函数，全部对应同一个系统调用，即102号系统调用，即sys_socketcall函数。
sys_socketcall函数如何处理用户的socket请求
所有的socket相关的C库函数，如socket、bind、connect、listen、accept、send、recv、sendto、sendmsg等，全部都属于同一个系统调用（即102号系统调用），全部由这一个函数处理。
此函数的代大致如下(源码文件netSocket.c)
long sys_socketcall(int call, unsigned long __user *args)
{
……
switch (call) {
case SYS_SOCKET:
err = sys_socket(a0, a1, a[2]);
break;
case SYS_BIND:
err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
break;
case SYS_CONNECT:
err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
break;
case SYS_LISTEN:
err = sys_listen(a0, a1);
break;
case SYS_ACCEPT:
err =
sys_accept(a0, (struct sockaddr __user *)a1,
(int __user *)a[2]);
break;
case SYS_GETSOCKNAME:
err =
sys_getsockname(a0, (struct sockaddr __user *)a1,
(int __user *)a[2]);
break;
case SYS_GETPEERNAME:
err =
sys_getpeername(a0, (struct sockaddr __user *)a1,
(int __user *)a[2]);
break;
case SYS_SOCKETPAIR:
err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
break;
case SYS_SEND:
err = sys_send(a0, (void __user *)a1, a[2], a[3]);
break;
case SYS_SENDTO:
err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
(struct sockaddr __user *)a[4], a[5]);
break;
case SYS_RECV:
err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
break;
case SYS_RECVFROM:
err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
(struct sockaddr __user *)a[4],
(int __user *)a[5]);
break;
case SYS_SHUTDOWN:
err = sys_shutdown(a0, a1);
break;
case SYS_SETSOCKOPT:
err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
break;
case SYS_GETSOCKOPT:
err =
sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
(int __user *)a[4]);
break;
case SYS_SENDMSG:
err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
break;
case SYS_RECVMSG:
err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
break;
default:
err = -EINVAL;
break;
}
return err;
}
（四）socket的创建
使用上述C库函数，第一步当然是使用socket库函数创建一个socket。后续的操作，则都是针对这一步创建出的socket而进行了。因此，我们先来看看socket的创建。
创建socket，主要就是分配一个struct socket结构变量，并适当的初始化。
这个工作由sys_socket 通过如下形式调用sock_create完成。其中的参数family、type、protocol都是用户调用socket库函数时传入的。
sock_create(family, type, protocol, &sock);
sock_create成功返回后，就创建了一个struct socket结构变量。
后续的数据收发，状态维护，差不多都基于这个结构变量了。
struct socket结构如下(源码文件：netSocket.c)
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;
};
这个结构的初始化，主要依赖于family, type, protocol这三项信息，查找到相应的协议栈模块，填充struct socket结构中相应的成员。
这个初始化过程的层次比较深，涉及较多细节。在下也没有深入阅读理解。
不过，我们可以简单看看大的数据结构。
内核中的协议栈，也是按family, type, protocol这三项信息进行了组织。
a) 固定的协议信息(netipv4 Af_inet.c)
Socket的创建，需要根据family, type, protocol确定一个协议。
内核中固定的协议信息，都在inetsw_array中进行了登记。
Static struct inet_protosw inetsw_array[] =
{
{
.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,
},
{
.type = SOCK_DGRAM,
.protocol = IPPROTO_UDP,
.prot = &udp_prot,
.ops = &inet_dgram_ops,
.capability = -1,
.no_check = UDP_CSUM_DEFAULT,
.flags = INET_PROTOSW_PERMANENT,
},
{
.type = SOCK_RAW,
.protocol = IPPROTO_IP, /* wild card */
.prot = &raw_prot,
.ops = &inet_sockraw_ops,
.capability = CAP_NET_RAW,
.no_check = UDP_CSUM_DEFAULT,
.flags = INET_PROTOSW_REUSE,
}
};
数组中的每个元素，对应一个协议。
其中，每个元素的prot成员，指向相应的协议（如TCP、UDP等）提供的proto结构变量，其中含有大量的函数指针，指向相应的函数，这些函数用于实现各种协议的交互、收发、控制等。这样一来，每一个协议，在这个数组中都能查到了，如何操作使用他们，也都有了相应的信息。
每个协议的ops成员，也指向一个proto_ops结构变量，其中也包含大量函数指针。这些操作，可以认为是包装后的，更抽象的操作。是更接近用户的socket操作函数。例如，这些操作函数包括：bind、connect、listen等。
具体包含哪些操作，是由family, type决定的（例如，family=PF_INET，type=SOCK_DGRAM时，则使用sendmsg接收数据）。对于多个协议，即使实现不同，但是如果他们的family, type相同，那么对于用户来说，操作都是一样的。
初始化完成后，最终的情况是：
a) socket.sk.__sk_common.skc_prot指向具体的协议提供的proto结构变量。内含大量函数，实现具体的协议操作。
b) socket. ops 指向相应的proto_ops结构变量，实现各种socket操作。
c) 最终的流程是：socket. ops包装了socket操作，但是socket. ops中的函数是利用socket.sk.__sk_common.skc_prot中的函数完成最终的操作。
最后，inetsw_array中的元素（协议），不是遍历查找的。他们被按照type分类组织到中inetsw了。Inetsw包含了PF_INET协议族中的全部协议。
Inetsw是个链表数组，定义如下(源码文件netipv4 Af_inet.c)。
static struct list_head inetsw[SOCK_MAX];
（五）使用socket进行收发
上一步已经完成了相关的初始化工作。
后续的建链、收发、断链等操作，也还都是由socketcall这一个函数完成的。
有兴趣的朋友可以自己研习研习相关的代码了。
在下对这方面也没有深入阅读理解:)