Linux TCP/IP 协议栈之 Socket的实现分析

时间:2022-07-20 11:05:00
原文地址:http://blog.csdn.net/zyq2007/article/details/6576403
Linux TCP/IP 协议栈之 Socket的实现分析(一  套接字的创建) 
 
[size=6]Linux TCP/IP 协议栈之 Socket的实现分析[/size] 
 
内核版本:2.6.12 
作者:kendo 
版权所有,转载请注明出处[[url]www.skynet.org.cn[/url]]; 
说明:这仅仅是一个笔记,由于偶的水平有限,我甚至不能保证其中内容正确率超过 80%。另外,
我不太习惯在代码中注解来自哪个文件,第几行之类的,因为偶是直接通过 source insight 双击鼠标
跳转之。 
 
[size=5]第一部份 Socket套接字的创建[/size] 
 
socket 并不是 TCP/IP 协议的一部份。 
从广义上来讲,socket 是 Unix/Linux 抽像的进程间通讯的一种方法。网络 socket 通讯仅仅是其若干
协议中的一类。而 tcp/ip又是网络这类中的一种。 
从 tcp/ip 的解度看 socket,它更多地体现了用户 API 与协议栈的一个中间层接口层。用户通过调用
socket API将报文递交给协议栈,或者从协议栈中接收报文件。 
 
[color=Red][size=5]一、系统总入口[/size][/color] 
 
Linux 内核为所有的与 socket 有关的操作的 API,提供了一个统一的系统调用入口,其代码在
net/socket.c中: 
[code]asmlinkage long sys_socketcall(int call, unsigned long __user *args) 

        unsigned long a[6]; 
        unsigned long a0,a1; 
        int err; 
 
        if(call<1||call>SYS_RECVMSG) 
                return -EINVAL; 
 
        /* copy_from_user should be SMP safe. */ 
        if (copy_from_user(a, args, nargs[call])) 
                return -EFAULT; 
                 
        a0=a[0]; 
        a1=a[1]; 
         
        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; 
}[/code] 
 
首先调用 copy_from_user将用户态参数拷贝至数组 a。但是问题在于,每个被调用的 API 的参数不
尽相同,那么每次拷贝的字节在小如果断定? 
来看其第三个参数 nargs[call],其中 call 是操作码,后面有个大大的 switch...case 就是判断它。对应
的操作码定义在 include/linux/net.h: 
[code]#define SYS_SOCKET        1                /* sys_socket(2)                */ 
#define SYS_BIND        2                /* sys_bind(2)                        */ 
#define SYS_CONNECT        3                /* sys_connect(2)                */ 
#define SYS_LISTEN        4                /* sys_listen(2)                */ 
#define SYS_ACCEPT        5                /* sys_accept(2)                */ 
#define SYS_GETSOCKNAME        6                /* sys_getsockname(2)                */ 
#define SYS_GETPEERNAME        7                /* sys_getpeername(2)                */ 
#define SYS_SOCKETPAIR        8                /* sys_socketpair(2)                */ 
#define SYS_SEND        9                /* sys_send(2)                        */ 
#define SYS_RECV        10                /* sys_recv(2)                        */ 
#define SYS_SENDTO        11                /* sys_sendto(2)                */ 
#define SYS_RECVFROM        12                /* sys_recvfrom(2)                */ 
#define SYS_SHUTDOWN        13                /* sys_shutdown(2)                */ 
#define SYS_SETSOCKOPT        14                /* sys_setsockopt(2)                */ 
#define SYS_GETSOCKOPT        15                /* sys_getsockopt(2)                */ 
#define SYS_SENDMSG        16                /* sys_sendmsg(2)                */ 
#define SYS_RECVMSG        17                /* sys_recvmsg(2)                */[/code] 
 
而数组 nargs则根据操作码的不同,计算对应的参数的空间大小: 
[code]/* Argument list sizes for sys_socketcall */ 
#define AL(x) ((x) * sizeof(unsigned long)) 
static unsigned char nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 
                                 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 
                                 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)}; 
#undef AL[/code] 
 
当拷贝完成参数后,就进入一个 switch...case...判断操作码,跳转至对应的系统接口。 [color=Red][size=5]二、 sys_socket 函数[/size][/color] 
 
操作码 SYS_SOCKET 是由 sys_socket()实现的: 
[code]asmlinkage long sys_socket(int family, int type, int protocol) 

        int retval; 
        struct socket *sock; 
 
        retval = sock_create(family, type, protocol, &sock); 
        if (retval < 0) 
                goto out; 
 
        retval = sock_map_fd(sock); 
        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; 
}[/code] 
 
在分析这段代码之间,首先来看,创建一个 Socket,对内核而言,究竟意味着什么?究竟需要内核
干什么事? 
 
当用户空间要创建一个 socke 接口时,会调用 API 函数: 
[code]int socket(int domain, int type, int protocol);[/code] 
 
函数,其三个参数分别表示协议族、协议类型(面向连接或无连接)以及协议。 
 
对于用户态而言,一个 Scoket,就是一个特殊的,已经打开的文件。为了对 socket抽像出文件的概
念,内核中为 socket 定义了一个专门的文件系统类型 sockfs: 
static struct vfsmount *sock_mnt; 
 
[code]static struct file_system_type sock_fs_type = { 
        .name =                "sockfs", 
        .get_sb =        sockfs_get_sb, 
        .kill_sb =        kill_anon_super, 
};[/code] 
 
在模块初始化的时候,安装该文件系统:  
[code]void __init sock_init(void) 

        …… 
        register_filesystem(&sock_fs_type); 
        sock_mnt = kern_mount(&sock_fs_type);         
}[/code] 
 
稍后还要回来继续分析安装中的一点细节。 
 
有了文件系统后,对内核而言,创建一个 socket, 就是在 sockfs 文件系统中创建一个文件节点(inode),
并建立起为了实现 socket 功能所  需的一整套数据结构,包括 struct inode 和 struct socket 结构。 struct 
socket 结构在内核中,就代表了一个"Socket",当一个 struct socket 数据结构被分配空间后,再将其
与一个已打开的文件“建立映射关系”。这样,用户态就可以用抽像的文件的概念来操作socket了——
当然,由  于网络的特殊性,至少就目前而言,这种抽像,并不如其它模块的抽像那么完美。 
 
这里socket的实现,和文件系统密切相关。这里就不再分析Linux的文件系统了,这里只分配与socket
相关的一些细节,其它的都一一跳过,呵呵,希望也能有水平再写一篇《Linux 文件系统的设计与
实现简析》。 
 
文件系统 struct vfsmount 中有一个成员指针 mnt_sb 指向该文件系统的超级块,而超级块结构 struct 
super_lock 有一个重要的成员 s_op 指向了超级块的操作函数表,其中有函数指针 alloc_inode()即为
在给定的超级块下创建并初始化一 个新的索引节点对像。也就是调用: 
[code]sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);[/code] 
当然,连同相关的处理细节一起,这一操作被层层封装至一个上层函数 new_inode()。 
 
那如何分配一个 struct socket 结构呢?如前所述,一个 socket 总是与一个inode 密切相关的。当然,
在 inode 中,设置一个 socket 成员,是完全可行的,但是  这貌似浪费了空间——毕竟,更多的文件
系统没有 socket 这个东东。所以,内核引入了另一个 socket_alloc 结构: 
[code]struct socket_alloc { 
        struct socket socket; 
        struct inode vfs_inode; 
};[/code] 
显而易见,该结构实现了 inode 和 socket 的封装。已经一个 inode,可以通过宏 SOCKET_I 来获取
与之对应的 socket: 
sock = SOCKET_I(inode); 
 
static inline struct socket *SOCKET_I(struct inode *inode) 

        return &container_of(inode, struct socket_alloc, vfs_inode)->socket; 

 
但是,这样做,也同时意味着,在分配一个 inode 后,必须再分配一个 socket_alloc结构,并实现对
应的封装。否则,container_of 又能到哪儿去找到 socket 呢?现在来简要地看一个这个流程——这是文件系统安装中的一个重要步骤: 
[code]struct vfsmount *kern_mount(struct file_system_type *type) 

        return do_kern_mount(type->name, 0, type->name, NULL); 
}[/code] 
 
[code]struct vfsmount * 
do_kern_mount(const char *fstype, int flags, const char *name, void *data) 

        struct file_system_type *type = get_fs_type(fstype); 
        struct super_block *sb = ERR_PTR(-ENOMEM); 
                …… 
                sb = type->get_sb(type, flags, name, data); 
                …… 
               mnt->mnt_sb = sb; 
               …… 
}[/code] 
 
do_kern_mount 函数中,先根据注册的文件系统类型,调用 get_fs_type 获取之,也就是我们之前注
册的 sock_fs_type,然后调用它的 get_sb 成员函数指针,获取相应的超级块 sb。最后,调置文件系
统的超级块成员指针,使之指向对应的值。 
这里 get_sb函数指针,指向之前初始化的 sockfs_get_sb()函数。 
static struct super_block *sockfs_get_sb(struct file_system_type *fs_type, 
        int flags, const char *dev_name, void *data) 

        return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC); 

 
注意其第三个参数 sockfs_ops,它封装了 sockfs 的功能函数表: 
[code]static struct super_operations sockfs_ops = { 
        .alloc_inode =        sock_alloc_inode, 
        .destroy_inode =sock_destroy_inode, 
        .statfs =        simple_statfs, 
};[/code] 
 
[code]struct super_block * 
get_sb_pseudo(struct file_system_type *fs_type, char *name, 
        struct super_operations *ops, unsigned long magic) 

        struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL); 
                …… 
         
                s->s_op = ops ? ops : &default_ops; 
}[/code]  
这里就是先获取/分配一个超级块,然后初始化超级块的各成员,包括 s_op,我们前面提到过它,
它封装了对应的功能函数表。这里 s_op 自然就指向了 sockfs_ops。那前面提到的 new_inode()函数
分配 inode 时调用的: 
[code]sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);[/code] 
这个 alloc_inode 函数指针也就是 sockfs_ops的 sock_alloc_inode()函数——转了一大圈,终于指到它
了。 
来看看 sock_alloc_inode 是如何分配一个 inode 节点的: 
[code]static struct inode *sock_alloc_inode(struct super_block *sb) 

        struct socket_alloc *ei; 
        ei = (struct socket_alloc *)kmem_cache_alloc(sock_inode_cachep, SLAB_KERNEL); 
        if (!ei) 
                return NULL; 
        init_waitqueue_head(&ei->socket.wait); 
         
        ei->socket.fasync_list = NULL; 
        ei->socket.state = SS_UNCONNECTED; 
        ei->socket.flags = 0; 
        ei->socket.ops = NULL; 
        ei->socket.sk = NULL; 
        ei->socket.file = NULL; 
        ei->socket.flags = 0; 
 
        return &ei->vfs_inode; 
}[/code] 
 
函数先分配了一个用于封装 socket 和 inode 的 ei,然后在高速缓存中为之申请了一块空间。这样,
inode 和 socket 就同时都被分配了。接下来初始化 socket 的各个成员,这些成员,在后面都会一一
提到。 
[code]/** 
*  struct socket - general BSD socket 
*  @state: socket state (%SS_CONNECTED, etc) 
*  @flags: socket flags (%SOCK_ASYNC_NOSPACE, etc) 
*  @ops: protocol specific socket operations 
*  @fasync_list: Asynchronous wake up list 
*  @file: File back pointer for gc 
*  @sk: internal networking protocol agnostic socket representation 
*  @wait: wait queue for several uses 
*  @type: socket type (%SOCK_STREAM, etc) 
*/ 
struct socket { 
        socket_state                state; 
        unsigned long                flags;         struct proto_ops        *ops; 
        struct fasync_struct        *fasync_list; 
        struct file                *file; 
        struct sock                *sk; 
        wait_queue_head_t        wait; 
        short                        type; 
};[/code] 
 
OK,至目前为止,分配 inode、socket 以及两者如何关联,都已一一分析了。 
最后一个关键问题,就是如何把 socket 与一个已打开的文件,建立映射关系。 
 
在内核中,用 struct file结构描述一个已经打开的文件,指向该结构的指针内核中通常用 file或 filp
来描述。我们知道,内核中,可以通过全局项 current 来获得当  前进程,它是一个 struct task_struct
类型的指针。tastk_struct 有一个成员: 
struct files_struct *files; 
指向一个已打开的文件。当然,由于一个进程可能打开多个文件,所以,struct files_struct 结构有 
struct file * fd_array[NR_OPEN_DEFAULT]; 
成员,这是个数组,以文件描述符为下标,即 current->files->fd[fd],可以找到与当前进程指定文件
描述符的文件。 
 
有了这些基础,如果要把一个 socket 与一个已打开的文件建立映射,首先要做的就是为 socket分配
一个struct file,并申请分配一个相应的文件描述符fd。因为socket并不支持open方法(前面说socket
的文件界面的抽像并不完美,这应该是一个佐证 吧?),所以不能期望用户界面通过调用 open() API
来分配一个 struct file,而是通过调用 get_empty_filp 来获取: 
[code]struct file *file = get_empty_filp();[/code] 
 
同样地: 
[code]int fd; 
fd = get_unused_fd();[/code] 
获取一个空间的文件描述符 
 
然后,让 current 的 files指针的 fd 数组的 fd 索引项指向该 file: 
 
[code]void fastcall fd_install(unsigned int fd, struct file * file) 

        struct files_struct *files = current->files; 
        spin_lock(&files->file_lock); 
        if (unlikely(files->fd[fd] != NULL)) 
                BUG(); 
        files->fd[fd] = file; 
        spin_unlock(&files->file_lock); 
}[/code] 
 
OK,做到这一步,有了一个文件描述符 fd 和一个打开的文件 file,它们与当前进程相连,但是好像与创建的socket并无任何瓜葛。要做的映射还是没  有进展。 struct file或者文件描述述fd或current
都没有任何能够与 inode或者是 socket 相关的东东。这需要一个中间的桥梁,目录项:struct dentry
结构。 
因为一个文件都有与其对应的目录项: 
struct file { 
        struct list_head        f_list; 
        struct dentry                *f_dentry; 
…… 
 
而一个目录项: 
struct dentry { 
…… 
        struct inode *d_inode;                /* Where the name belongs to - NULL is 
                                         * negative */ 
 
d_inode 成员指向了与之对应的 inode节点…… 
 
而之前已经创建了一个 inode 节点和与之对应的 socket。 
所以,现在要做的,就是: 
“先为当前文件分配一个对应的目录项,再将已创建的 inode节点安装至该目录项” 
这样,一个完成的映射关系: 
进程、文件描述符、打开文件、目录项、inode节点、socket就完整地串起来了。 
 
基本要分析的一些前导的东东都一一罗列了,虽然已尽量避免陷入文件系统的细节分析,但是还是
不可避免地进入其中,因为它们关系实现太紧密了。现在可以来看套接字的创建过程了: 
 
[code]asmlinkage long sys_socket(int family, int type, int protocol) 

        int retval; 
        struct socket *sock; 
 
        retval = sock_create(family, type, protocol, &sock); 
        if (retval < 0) 
                goto out; 
 
        retval = sock_map_fd(sock); 
        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; 
}[/code] 
 
[code]int sock_create(int family, int type, int protocol, struct socket **res) 

        return __sock_create(family, type, protocol, res, 0); 
}[/code] 
 
[color=Red][size=5]三、af_inet 协议簇的协议封装[/size][/color] 
 
接下来,函数调用之前已经注的 inet_family_ops的函数指针 create,也就是inet_create()函数,前面,
可以说一个通用的 socket 已经创建好了,这里要完成与协议本身相关的一些创建 socket 的工作。
这一部份的工作比较复杂,还是先来看看 af_inet.c 中的模块初  始化时候,做了哪些与此相关的工
作。 
 
要引入的第一个数据结构是 struct inet_protosw,它封装了一个协议类型(如 SOCK_STREAM、
SOCK_DGRAM 等)与 ip 协议中对应的传输层协议: 
[code]/* This is used to register socket interfaces for IP protocols.  */ 
struct inet_protosw { 
        struct list_head list; 
 
        /* These two fields form the lookup key.  */ 
        unsigned short         type;           /* This is the 2nd argument to socket(2). */ 
        int                 protocol; /* This is the L4 protocol number.  */ 
 
        struct proto         *prot; 
        struct proto_ops *ops; 
   
        int              capability; /* Which (if any) capability do 
                                      * we need to use this socket 
                                      * interface? 
                                      */ 
        char             no_check;   /* checksum on rcv/xmit/none? */ 
        unsigned char         flags;      /* See INET_PROTOSW_* below.  */ 
}; 
#define INET_PROTOSW_REUSE 0x01             /* Are ports automatically reusable? */ 
#define INET_PROTOSW_PERMANENT 0x02  /* Permanent protocols are unremovable. */[/code] 
 
type  是协议类型,对于 ipv4 而言,就是 SOCK_STREAM、SOCK_DGRAM 或者是 SOCK_RAW 之
一。protocol 是传输层的协议号。 prot 用于描述一个具体的传输层协议,而 ops 指向对应的当前协
议类型的操作函数集。针对不同的协议类型,定义了不同的 ops: 
 
[code]struct proto_ops inet_stream_ops = {         .family =        PF_INET, 
        .owner =        THIS_MODULE, 
        .release =        inet_release, 
        .bind =                inet_bind, 
        .connect =        inet_stream_connect, 
        .socketpair =        sock_no_socketpair, 
        .accept =        inet_accept, 
        .getname =        inet_getname, 
        .poll =                tcp_poll, 
        .ioctl =        inet_ioctl, 
        .listen =        inet_listen, 
        .shutdown =        inet_shutdown, 
        .setsockopt =        sock_common_setsockopt, 
        .getsockopt =        sock_common_getsockopt, 
        .sendmsg =        inet_sendmsg, 
        .recvmsg =        sock_common_recvmsg, 
        .mmap =                sock_no_mmap, 
        .sendpage =        tcp_sendpage 
};[/code] 
 
[code]struct proto_ops inet_dgram_ops = { 
        .family =        PF_INET, 
        .owner =        THIS_MODULE, 
        .release =        inet_release, 
        .bind =                inet_bind, 
        .connect =        inet_dgram_connect, 
        .socketpair =        sock_no_socketpair, 
        .accept =        sock_no_accept, 
        .getname =        inet_getname, 
        .poll =                udp_poll, 
        .ioctl =        inet_ioctl, 
        .listen =        sock_no_listen, 
        .shutdown =        inet_shutdown, 
        .setsockopt =        sock_common_setsockopt, 
        .getsockopt =        sock_common_getsockopt, 
        .sendmsg =        inet_sendmsg, 
        .recvmsg =        sock_common_recvmsg, 
        .mmap =                sock_no_mmap, 
        .sendpage =         inet_sendpage, 
};[/code] 
 
[code]/* 
* For SOCK_RAW sockets; should be the same as inet_dgram_ops but without 
* udp_poll */ 
static struct proto_ops inet_sockraw_ops = { 
        .family =        PF_INET, 
        .owner =        THIS_MODULE, 
        .release =        inet_release, 
        .bind =                inet_bind, 
        .connect =        inet_dgram_connect, 
        .socketpair =        sock_no_socketpair, 
        .accept =        sock_no_accept, 
        .getname =        inet_getname, 
        .poll =                datagram_poll, 
        .ioctl =        inet_ioctl, 
        .listen =        sock_no_listen, 
        .shutdown =        inet_shutdown, 
        .setsockopt =        sock_common_setsockopt, 
        .getsockopt =        sock_common_getsockopt, 
        .sendmsg =        inet_sendmsg, 
        .recvmsg =        sock_common_recvmsg, 
        .mmap =                sock_no_mmap, 
        .sendpage =         inet_sendpage, 
};[/code] 
 
从各个函数指针的名称,我们就可以大约知道它们是做什么事的了。进一步进以看到,它们的函数
指针指向的函数差不多都是相同的。除了一些细节上的区别,例如后面两种协议类型并不支持listen。  
 
socket() API 第二个参数是协议类型,第三个参数是该协议类型下的协议——不过对于 ipv4 而言,
它们都是一一对应的。但是从抽像封装的角度看,数据结构的设计本  身应该满足一个协议类型下
边,可能存在多个不同的协议,即一对多的情况。而一一对应,仅是它们的特例: 
[code]/* Upon startup we insert all the elements in inetsw_array[] into 
* the linked list inetsw. 
*/ 
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, 
        }, 
 
        {                 .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, 
       } 
};[/code] 
 
数组的每一个元素,就是支持的一种协议名称,例如 IPOROTO_TCP,但是由于 IPV4 本身协议类
型跟协议是一一对应的,所以没有更多的.type= SOCK_xxx 了。这样数组实现了对 PF_INET 协议族
下支持的协议类型,以及协议类型下边的协议进行了封装,虽然事实上它们是一一对应的关系,不
过  理论上,完全可能存在一对多的可能。 
 
数组内,封装的一个具体的协议,由 struct proto 结构来描述: 
[code]/* Networking protocol blocks we attach to sockets. 
* socket layer -> transport layer interface 
* transport -> network interface is defined by struct inet_proto 
*/ 
struct proto { 
        void                        (*close)(struct sock *sk,  
                                        long timeout); 
        int                        (*connect)(struct sock *sk, 
                                        struct sockaddr *uaddr,  
                                        int addr_len); 
        int                        (*disconnect)(struct sock *sk, int flags); 
 
        struct sock *                 (*accept) (struct sock *sk, int flags, int *err); 
 
        int                        (*ioctl)(struct sock *sk, int cmd, 
                                         unsigned long arg); 
        int                        (*init)(struct sock *sk);         int                        (*destroy)(struct sock *sk); 
        void                        (*shutdown)(struct sock *sk, int how); 
        int                        (*setsockopt)(struct sock *sk, int level,  
                                        int optname, char __user *optval, 
                                        int optlen); 
        int                        (*getsockopt)(struct sock *sk, int level,  
                                        int optname, char __user *optval,  
                                        int __user *option);            
        int                        (*sendmsg)(struct kiocb *iocb, struct sock *sk, 
                                           struct msghdr *msg, size_t len); 
        int                        (*recvmsg)(struct kiocb *iocb, struct sock *sk, 
                                           struct msghdr *msg, 
                                        size_t len, int noblock, int flags,  
                                        int *addr_len); 
        int                        (*sendpage)(struct sock *sk, struct page *page, 
                                        int offset, size_t size, int flags); 
        int                        (*bind)(struct sock *sk,  
                                        struct sockaddr *uaddr, int addr_len); 
 
        int                        (*backlog_rcv) (struct sock *sk,  
                                                struct sk_buff *skb); 
 
        /* Keeping track of sk's, looking them up, and port selection methods. */ 
        void                        (*hash)(struct sock *sk); 
        void                        (*unhash)(struct sock *sk); 
        int                        (*get_port)(struct sock *sk, unsigned short snum); 
 
        /* Memory pressure */ 
        void                        (*enter_memory_pressure)(void); 
        atomic_t                *memory_allocated;        /* Current allocated memory. */ 
        atomic_t                *sockets_allocated;        /* Current number of sockets. */ 
        /* 
         * Pressure flag: try to collapse. 
         * Technical note: it is used by multiple contexts non atomically. 
         * All the sk_stream_mem_schedule() is of this nature: accounting 
         * is strict, actions are advisory and have some latency. 
         */ 
        int                        *memory_pressure; 
        int                        *sysctl_mem; 
        int                        *sysctl_wmem; 
        int                        *sysctl_rmem; 
        int                        max_header; 
 
        kmem_cache_t                *slab;         unsigned int                obj_size; 
 
        struct module                *owner; 
 
        char                        name[32]; 
 
        struct list_head        node; 
 
        struct { 
                int inuse; 
                u8  __pad[SMP_CACHE_BYTES - sizeof(int)]; 
        } stats[NR_CPUS]; 
};[/code] 
 
以 TCP协议为例,TCP协议的 sokcet 操作函数都被封装在这里了。 
 
[code]struct proto tcp_prot = { 
        .name                        = "TCP", 
        .owner                        = THIS_MODULE, 
        .close                        = tcp_close, 
        .connect                = tcp_v4_connect, 
        .disconnect                = tcp_disconnect, 
        .accept                        = tcp_accept, 
        .ioctl                        = tcp_ioctl, 
        .init                        = tcp_v4_init_sock, 
        .destroy                = tcp_v4_destroy_sock, 
        .shutdown                = tcp_shutdown, 
        .setsockopt                = tcp_setsockopt, 
        .getsockopt                = tcp_getsockopt, 
        .sendmsg                = tcp_sendmsg, 
        .recvmsg                = tcp_recvmsg, 
        .backlog_rcv                = tcp_v4_do_rcv, 
        .hash                        = tcp_v4_hash, 
        .unhash                        = tcp_unhash, 
        .get_port                = tcp_v4_get_port, 
        .enter_memory_pressure        = tcp_enter_memory_pressure, 
        .sockets_allocated        = &tcp_sockets_allocated, 
        .memory_allocated        = &tcp_memory_allocated, 
        .memory_pressure        = &tcp_memory_pressure, 
        .sysctl_mem                = sysctl_tcp_mem, 
        .sysctl_wmem                = sysctl_tcp_wmem, 
        .sysctl_rmem                = sysctl_tcp_rmem, 
        .max_header                = MAX_TCP_HEADER, 
        .obj_size                = sizeof(struct tcp_sock), };[/code] 
 
[color=Red][size=5]四、分配 struct sock(sk)[/size][/color] 
 
浏览到这里,看完了 PF_INET 的协议簇、协议类型和协议(也就是 socket调用的三个参数)的封装关
系,它们通过了两个数据结构 inet_protosw、struct proto 来描述,被一个数组 inetsw_array所封装。
接下来看它的初始化工作: 
[code]static struct list_head inetsw[SOCK_MAX]; 
static int __init inet_init(void) 

…… 
        /* Register the socket-side information for inet_create. */ 
        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); 
…… 
}[/code] 
 
inetsw 是一个数组,其每一个元素,都是一个链表首部,前面一个循环初始化之。后一个循环就值
得注意了,也就是函数 
inet_register_protosw: 
 
[code]void inet_register_protosw(struct inet_protosw *p) 

        struct list_head *lh; 
        struct inet_protosw *answer; 
        int protocol = p->protocol; 
        struct list_head *last_perm; 
 
        spin_lock_bh(&inetsw_lock); 
 
        if (p->type >= SOCK_MAX) 
                goto out_illegal; 
 
        /* If we are trying to override a permanent protocol, bail. */ 
        answer = NULL; 
        last_perm = &inetsw[p->type]; 
        list_for_each(lh, &inetsw[p->type]) { 
                answer = list_entry(lh, struct inet_protosw, list); 
 
                /* Check only the non-wild match. */ 
                if (INET_PROTOSW_PERMANENT & answer->flags) {                         if (protocol == answer->protocol) 
                                break; 
                        last_perm = lh; 
                } 
 
                answer = NULL; 
        } 
        if (answer) 
                goto out_permanent; 
 
        /* Add the new entry after the last permanent entry if any, so that 
         * the new entry does not override a permanent entry when matched with 
         * a wild-card protocol. But it is allowed to override any existing 
         * non-permanent entry.  This means that when we remove this entry, the  
         * system automatically returns to the old behavior. 
         */ 
        list_add_rcu(&p->list, last_perm); 
out: 
        spin_unlock_bh(&inetsw_lock); 
 
        synchronize_net(); 
 
        return; 
 
out_permanent: 
        printk(KERN_ERR "Attempt to override permanent protocol %d./n", 
               protocol); 
        goto out; 
 
out_illegal: 
        printk(KERN_ERR 
               "Ignoring attempt to register invalid socket type %d./n", 
               p->type); 
        goto out; 
}[/code] 
 
这个函数完成的工作,就是把 inetsw_array 数组中,相同的协议类型下边的协议,加入到 inetsw 对
应的协议类型的链表中去。因为事实上一对一  的关系,所以这个函数要简单得多:因为不存在其
它成员,所以每一次 list_entry 都为空值,所以不存在覆盖和追加的情况,直接调用 
list_add_rcu(&p->list, last_perm);把协议类型节点(struct inet_protosw  类型的数组的某个元素)添加到
链表(链表首部本身是一个数组,数组索引是协议对应的协议类型的值)的第一个成员。 
 
来做一个假设,如果 SOCK_STREAM 协议类型下边还有另一个协议,IPPROTO_123,那么
inetsw_array数组中就会多出一个元素: [code]        { 
                .type =       SOCK_STREAM, 
                .protocol =   IPPROTO_123, 
                .prot =       &123_prot, 
                …… 
        },[/code] 
 
这样,当遍历 inetsw_array,再次进入 inet_register_protosw 函数后,因为 SOCK_STREAM 类型下
已经注册了 IPPROTO_TCP,所以, 
[code]        list_for_each(lh, &inetsw[p->type]) { 
                answer = list_entry(lh, struct inet_protosw, list); 
 
                /* Check only the non-wild match. */ 
                if (INET_PROTOSW_PERMANENT & answer->flags) { 
                        if (protocol == answer->protocol)        /*  已经注册了相同协议号,退出循环,
因为没有置 answer 为 NULL,所以后面会直接退出函数 */ 
                                break; 
                        last_perm = lh;                                /*  移动位置指针,指向链表中最后一
个元素 */ 
                } 
 
                answer = NULL; 
        }[/code] 
这个循环,answer 就会指向之前注册的 TCP 的链表节点,然后根据标志,如果是
INET_PROTOSW_PERMANENT,则 last_perm  指向链表中最后一个节点,也就是 TCP,之后同样
的道理,再把 123 追加到 TCP 之后,如果是 INET_PROTOSW_REUSE,因为位置指针 last_perm
没有移动,则之前注册的元素会被覆盖。 
 
OK,绕了这么大一圈子,了解了协议的封装及链表的注册。现在回到 inet_create 中来: 
 
[code]/* 
*        Create an inet socket. 
*/ 
 
static int inet_create(struct socket *sock, int protocol) 

        struct sock *sk; 
        struct list_head *p; 
        struct inet_protosw *answer; 
        struct inet_sock *inet; 
        struct proto *answer_prot; 
        unsigned char answer_flags; 
        char answer_no_check; 
        int err;          
        sock->state = SS_UNCONNECTED;[/code] 
socket 的初始状态设置为“未连接”,这意味着面向连接的协议类型,如 tcp,在使用之前必须建立连
接修改状态位。 
 
[code]        answer = NULL; 
        rcu_read_lock(); 
        list_for_each_rcu(p, &inetsw[sock->type]) { 
                answer = list_entry(p, struct inet_protosw, list); 
 
                /* 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; 
                } 
                answer = NULL; 
        }[/code] 
 
这个循环,根据 socket(2)调用的 protocol,把之前在链表中注册的协议节点找出来一个问题是,因
为一一对应关系的存在,用户态调用 socket(2)的时候,常常第三个参数直接就置 0 了。也就是这里
protocol  为 0。那内核又如何处理这一默认值呢?也就是 protocol != answer->protocol,而是被 if 
(IPPROTO_IP == protocol) 所匹配了。这样,将 protocol 置为链表中第一个协议。而当循环结束时,
answer自然也是指向这个链表中的第一个注册节点。以刚才的例  子,SOCK_STREAM 下同时注册
了 TCP和 123,那么这里默认就取 TCP了。当然,把 123 在inetsw_array数组中的位置调前,那么
就  默认取 123 了。 
 
[code]        err = -ESOCKTNOSUPPORT; 
        if (!answer) 
                goto out_rcu_unlock; 
        err = -EPERM; 
        if (answer->capability > 0 && !capable(answer->capability)) 
                goto out_rcu_unlock; 
        err = -EPROTONOSUPPORT; 
        if (!protocol) 
                goto out_rcu_unlock; 
        /*  找到了组织,将创建的 socket 的 ops 函数指针集,指向协议类型的。例如创建的是SOCK_STREAM,那么就指向了 inet_stream_ops */ 
        sock->ops = answer->ops; 
        /* answer_prot 指针指向了当前要创建的 socket 的协议类型下边的协议,如上例,它就是
IPPROTO_TCP 的 tcp_prot 结构 */ 
        answer_prot = answer->prot; 
        answer_no_check = answer->no_check; 
        answer_flags = answer->flags; 
        rcu_read_unlock(); 
 
        BUG_TRAP(answer_prot->slab != NULL); 
[/code] 
 
接下来一个重要的工作,就是为 socket 分配一个sock,并初始化它: 
[code]        err = -ENOBUFS; 
        sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1); 
        if (sk == NULL) 
                goto out; 
 
        err = 0; 
        sk->sk_no_check = answer_no_check; 
        if (INET_PROTOSW_REUSE & answer_flags) 
                sk->sk_reuse = 1; 
 
        inet = inet_sk(sk); 
 
        if (SOCK_RAW == sock->type) { 
                inet->num = protocol; 
                if (IPPROTO_RAW == protocol) 
                        inet->hdrincl = 1; 
        } 
 
        if (ipv4_config.no_pmtu_disc) 
                inet->pmtudisc = IP_PMTUDISC_DONT; 
        else 
                inet->pmtudisc = IP_PMTUDISC_WANT; 
 
        inet->id = 0; 
 
        sock_init_data(sock, sk); 
 
        sk->sk_destruct           = inet_sock_destruct; 
        sk->sk_family           = PF_INET; 
        sk->sk_protocol           = protocol; 
        sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;  
        inet->uc_ttl        = -1; 
        inet->mc_loop        = 1; 
        inet->mc_ttl        = 1; 
        inet->mc_index        = 0; 
        inet->mc_list        = NULL; 
 
#ifdef INET_REFCNT_DEBUG 
        atomic_inc(&inet_sock_nr); 
#endif 
 
        if (inet->num) { 
                /* It assumes that any protocol which allows 
                 * the user to assign a number at socket 
                 * creation time automatically 
                 * shares. 
                 */ 
                inet->sport = htons(inet->num); 
                /* Add to protocol hash chains. */ 
                sk->sk_prot->hash(sk); 
        } 
 
        if (sk->sk_prot->init) { 
                err = sk->sk_prot->init(sk); 
                if (err) 
                        sk_common_release(sk); 
        } 
out: 
        return err; 
out_rcu_unlock: 
        rcu_read_unlock(); 
        goto out; 
}[/code] 
 
虽然 create的代码就到这儿了,不过要说清楚 sk 的分配,还得费上大力气。 
每一个 Socket 套接字,都有一个对应的 struct socket 结构来描述(内核中一般使用名称为 sock),但
是同时又一个 struct sock 结构(内核中一般使用名称为 sk)。两者之间是一一对应的关系。在后面
的 sock_init_data 函数中,可以看到 
[code]sk->sk_socket                =        sock; 
sock->sk        =        sk;[/code]这样的代码。 
 
socket 结构和 sock 结构实际上是同一个事物的两个方面。不妨说,socket 结构是面向进程和系统调
用界面的侧面,而 sock 结构则是面向底层驱  动程序的侧面。设计者把 socket 套接字中,与文件系
统关系比较密切的那一部份放在 socket 结构中,而把与通信关系比较密切的那一部份,则单独成为 一个数结结构,那就是 sock 结构。由于这两部份逻辑上本来就是一体的,所以要通过指针互相指向
对方,形成一对一的关系。 
 
再暂时回到 inet_init 中来,初始化工作中,有如下代码: 
[code]        rc = proto_register(&tcp_prot, 1); 
        if (rc) 
                goto out; 
 
        rc = proto_register(&udp_prot, 1); 
        if (rc) 
                goto out_unregister_tcp_proto; 
 
        rc = proto_register(&raw_prot, 1); 
        if (rc) 
                goto out_unregister_udp_proto;[/code] 
 
这里为每个 protocol 都调用了 proto_register 函数,其重要功能之一,就是根据协议的 obj_size 成员
的大小,为协议创建高速缓存: 
[code]static DEFINE_RWLOCK(proto_list_lock); 
static LIST_HEAD(proto_list); 
 
int proto_register(struct proto *prot, int alloc_slab) 

        int rc = -ENOBUFS; 
 
        if (alloc_slab) { 
        /*  可以看到,函数最重要的功能就是根据 prot 的obj_size 成员的大小,为协议创建高速缓存 
*/         
                prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0, 
                if (prot->slab == NULL) { 
                        printk(KERN_CRIT "%s: Can't create sock SLAB cache!/n", 
                               prot->name); 
                        goto out; 
                } 
        } 
 
        /*  顺便看到它的另一个重要的功能,是维护一个以 proto_list 为首的链表 */ 
        write_lock(&proto_list_lock); 
        list_add(&prot->node, &proto_list); 
        write_unlock(&proto_list_lock); 
        rc = 0; 
out: 
        return rc; 
}[/code]  
这里要注意的是:prot->obj_size 的大小,它它非仅仅是一个 sk 的大小!! !以 TCP为例:.obj_size = 
sizeof(struct tcp_sock)。稍后再来分析这个东东。 
 
回到 inet_create()函数中来,其调用 sk_alloc()分配一个 sk: 
[code]sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);[/code] 
 
[code]struct sock *sk_alloc(int family, int priority, struct proto *prot, int zero_it) 

        struct sock *sk = NULL; 
        kmem_cache_t *slab = prot->slab; 
 
        if (slab != NULL) 
                sk = kmem_cache_alloc(slab, priority); 
        else 
                sk = kmalloc(prot->obj_size, priority); 
 
        if (sk) { 
                if (zero_it) { 
                        memset(sk, 0, prot->obj_size); 
                        sk->sk_family = family; 
                        /* 
                         * See comment in struct sock definition to understand 
                         * why we need sk_prot_creator -acme 
                         */ 
                        sk->sk_prot = sk->sk_prot_creator = prot; 
                        ……[/code] 
 
在之前创建的高速缓存中申请分配一个 slab 缓存项。并清零。然后设置协议族、并把 sk 中的 sk_prot
与对应的协议关联起来。 
 
[color=Red][size=5]五、初始化 sk[/size][/color] 
 
分配完成 sk 后,另一个重要的功能就是初始化它,sk 的成员相当复杂,其主要的初始化工作是在
函数 sock_init_data()中完成的: 
[code]void sock_init_data(struct socket *sock, struct sock *sk) 

        /*  初始化其三个队列 */ 
        skb_queue_head_init(&sk->sk_receive_queue); 
        skb_queue_head_init(&sk->sk_write_queue); 
        skb_queue_head_init(&sk->sk_error_queue); 
 
        sk->sk_send_head        =        NULL; 
         /*  初始化数据包发送定时器 */ 
        init_timer(&sk->sk_timer); 
         
        sk->sk_allocation        =        GFP_KERNEL; 
        sk->sk_rcvbuf                =        sysctl_rmem_default; 
        sk->sk_sndbuf                =        sysctl_wmem_default; 
        sk->sk_state                =        TCP_CLOSE; 
        /*  指向对应的 socket 结构 */ 
        sk->sk_socket                =        sock; 
 
        sock_set_flag(sk, SOCK_ZAPPED); 
 
        if(sock) 
        { 
                sk->sk_type        =        sock->type; 
                sk->sk_sleep        =        &sock->wait; 
                /*  回指对应的 scok 结构 */ 
                sock->sk        =        sk; 
        } else 
                sk->sk_sleep        =        NULL; 
 
        rwlock_init(&sk->sk_dst_lock); 
        rwlock_init(&sk->sk_callback_lock); 
 
        sk->sk_state_change        =        sock_def_wakeup; 
        sk->sk_data_ready        =        sock_def_readable; 
        sk->sk_write_space        =        sock_def_write_space; 
        sk->sk_error_report         =        sock_def_error_report; 
        sk->sk_destruct                =        sock_def_destruct; 
 
        sk->sk_sndmsg_page        =        NULL; 
        sk->sk_sndmsg_off        =        0; 
 
        sk->sk_peercred.pid         =        0; 
        sk->sk_peercred.uid        =        -1; 
        sk->sk_peercred.gid        =        -1; 
        sk->sk_write_pending        =        0; 
        sk->sk_rcvlowat                =        1; 
        sk->sk_rcvtimeo                =        MAX_SCHEDULE_TIMEOUT; 
        sk->sk_sndtimeo                =        MAX_SCHEDULE_TIMEOUT; 
 
        sk->sk_stamp.tv_sec     = -1L; 
        sk->sk_stamp.tv_usec    = -1L; 
         atomic_set(&sk->sk_refcnt, 1); 
}[/code] 
 
sock 结构中,有三个重要的双向队列,分别是 sk_receive_queue、sk_write_queue和 sk_error_queue。
从它们的名字就可以看出来其作用了。 
队列并非采用通用的 list_head 来维护,而是使用 skb_buffer 队列: 
[code]struct sk_buff_head { 
        /* These two members must be first. */ 
        struct sk_buff        *next; 
        struct sk_buff        *prev; 
 
        __u32                qlen; 
        spinlock_t        lock; 
};[/code] 
 
这样,队列中指向的每一个 skb_buffer,就是一个数据包,分别是接收、发送和投递错误。 
 
剩余的就是初始化其它成员变量了。后面再来专门分析这些成员的作用。 
 
inet_create 函数中,除了初始化 sk 成员的值,还有一部份代码,是初始化一个 inet的东东: 
[code]                inet = inet_sk(sk); 
        inet->uc_ttl        = -1; 
        inet->mc_loop        = 1; 
        inet->mc_ttl        = 1; 
        inet->mc_index        = 0; 
        inet->mc_list        = NULL;[/code] 
 
inet 是一个 struct inet_sock 结构类型,来看它的定义: 
[code]struct inet_sock { 
        /* sk and pinet6 has to be the first two members of inet_sock */ 
        struct sock                sk; 
               …… 
}[/code] 
只留意它的第一个成员就足够了。 
 
我们说 sock 是面向用户态调用,而 sk 是面向内核驱动调用的,那 sk 是如何与协议栈交互的呢?对
于每一个类型的协议,为了与 sk 联系起来,都定义了一个 struct XXX_sock 结构,XXX是协议名,
例如: 
[code]struct tcp_sock { 
        /* inet_sock has to be the first member of tcp_sock */ 
        struct inet_sock        inet; 
        int        tcp_header_len;        /* Bytes of tcp header to send                */ 
        …… 
}  
struct udp_sock { 
        /* inet_sock has to be the first member */ 
        struct inet_sock inet; 
        int                 pending;        /* Any pending frames ? */ 
        unsigned int         corkflag;        /* Cork is required */ 
          __u16                 encap_type;        /* Is this an Encapsulation socket? */ 
        /* 
         * Following member retains the infomation to create a UDP header 
         * when the socket is uncorked. 
         */ 
        __u16                 len;                /* total length of pending frames */ 
}; 
 
struct raw_sock { 
        /* inet_sock has to be the first member */ 
        struct inet_sock   inet; 
        struct icmp_filter filter; 
};[/code] 
 
很明显,它们的结构定构是“af_inet一般属性+自己的私有属性”,因为它们的第一个成员总是 inet。  
 
呵呵,现在回头来照一下起初在 af_inet.c 中,封装协议注册的时候,size成员,对于 tcp 而言: 
.obj_size                = sizeof(struct tcp_sock), 
其它协议类似。 
 
以 obj_size 来确定每个 slab 缓存项分配的大小,所以,我们就可说,每次申请分配的,实际上是一
个 struct XXX_sock 结构大小的结构。因为都是定义于上层结构的第一个成员,可以使用强制类型
转换来使用这块分配的内存空间。例如: 
[code]inet = inet_sk(sk); 
 
static inline struct inet_sock *inet_sk(const struct sock *sk) 

        return (struct inet_sock *)sk; 

 
struct tcp_sock *tp = tcp_sk(sk); 
 
static inline struct tcp_sock *tcp_sk(const struct sock *sk) 

        return (struct tcp_sock *)sk; 
}[/code] 
 
OK,inet_create()运行完,一个 socket 套接字基本上就创建完毕了,剩下的就是与文件系统挂钩,回到最初的 sys_socket()函数中来,它在调用完 sock_create()后,紧接着调用 sock_map_fd()函数: 
[code] 
int sock_map_fd(struct socket *sock) 

        int fd; 
        struct qstr this; 
        char name[32]; 
 
        /* 
         *        Find a file descriptor suitable for return to the user.  
         */ 
 
        fd = get_unused_fd(); 
        if (fd >= 0) { 
                struct file *file = get_empty_filp(); 
 
                if (!file) { 
                        put_unused_fd(fd); 
                        fd = -ENFILE; 
                        goto out; 
                } 
 
                sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino); 
                this.name = name; 
                this.len = strlen(name); 
                this.hash = SOCK_INODE(sock)->i_ino; 
 
                file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this); 
                if (!file->f_dentry) { 
                        put_filp(file); 
                        put_unused_fd(fd); 
                        fd = -ENOMEM; 
                        goto out; 
                } 
                file->f_dentry->d_op = &sockfs_dentry_operations; 
                d_add(file->f_dentry, SOCK_INODE(sock)); 
                file->f_vfsmnt = mntget(sock_mnt); 
                file->f_mapping = file->f_dentry->d_inode->i_mapping; 
 
                sock->file = file; 
                file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops; 
                file->f_mode = FMODE_READ | FMODE_WRITE; 
                file->f_flags = O_RDWR; 
                file->f_pos = 0;                 fd_install(fd, file); 
        } 
 
out: 
        return fd; 
}[/code] 
 
这个函数的核心思想,在一开始,就已经分析过了。从进程的角度来讲,一个socket 套接字就是一
个特殊的,已打开的文件。前面分配好一个 socket  后,这里要做的就是将它与文件系统拉上亲戚关
系。首先获取一个空闲的文件描述符号和 file 结构。然后在文件系统中分配一个目录项(d_alloc),
使  其指向已经分配的 inode 节点(d_add),然后把其目录项挂在 sockfs 文件系统的根目录之下。并
且把目录项的指针 d_op设置成指向 sockfs_dentry_operati,这个数据结构通过函数指针提供他与文
件路径有关的操作: 
[code]static struct dentry_operations sockfs_dentry_operations = { 
        .d_delete =        sockfs_delete_dentry, 
};[/code] 
 
最后一步,就是将 file 结构中的 f_op 和 sock 结构中的 i_fop 都指向 socket_file_ops,它是一个函数
指针集,指向了 socket面向文件系统的用户态调用的一些接口函数: 
[code]static struct file_operations socket_file_ops = { 
        .owner =        THIS_MODULE, 
        .llseek =        no_llseek, 
        .aio_read =        sock_aio_read, 
        .aio_write =        sock_aio_write, 
        .poll =                sock_poll, 
        .unlocked_ioctl = sock_ioctl, 
        .mmap =                sock_mmap, 
        .open =                sock_no_open,        /* special open code to disallow open via /proc */ 
        .release =        sock_close, 
        .fasync =        sock_fasync, 
        .readv =        sock_readv, 
        .writev =        sock_writev, 
        .sendpage =        sock_sendpage 
};[/code] 
 
OK,到这里,整个 socket 套接字的创建工作,就宣告完成了。 
 
 
写到这里,可以为 socket 的创建下一个小结了: 
1、所谓创建socket,对内核而言,最重要的工作就是分配 sock 与 sk; 
2、 sock 面向上层系统调用,主要是与文件系统交互。通过进程的 current 指针的 files,结合创建 socket
时返回的文件描符述,可以找到内  核中对应的 struct file,再根据 file的 f_dentry可以找到对应的目
录项,而目录项 struct dentry 中,有 d_inode 指针,指向与 sock 封装在一起的 inode。sock 又与 sk
指针互指,一一对应。在这串结构中,有两个重要的函数集  指针,一个是文件系统 struct file 中的f_op指针,它指向了,对应的用户态调用的read,write等操调用,但不支持open,另一个是struct socket
结构,即 sock 的ops 指针,它在 inet_create()中被置为 
sock->ops = answer->ops; 
指向具体协议类型的 ops;例如,inet_stream_ops、inet_dgram_ops 或者是 inet_sockraw_ops 等等。
它用来支持上层的 socket 的其它 API 调用。 
3、sk 面向内核协议栈,协议栈与它的接口数据结构是 struct protoname_sock,该结构中包含了一般
性的 inet 结构和自己的私有成员,struct inet_sock 的第一个成员就是一个 sk 指针,而分配的 sk,实
际上空间大小是 struct protoname_sock,所以,这三者可以通过强制类型转换来获取需要的指针。 
4、由于水平有限,文件系统的一些细节被我跳过了,sk 中的大多数成员变量的作用,也被我跳出
过了。呵呵,还好,终于还是把这块流程给初步分析出来了。另外,当时写的时候,没有想到会写
这么长,大大超出了每贴的字限制。所以,每个小节内容跟标题可能会有点对不上号。 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Linux TCP/IP 协议栈之 Socket的实现分析(二 Socket套接字的地址绑定) 
 
[color=Red][size=6]第二部份 Socket的bind(2),绑定地址[/size][/color] 
 
[size=5][color=Red]1、bind(2)[/color][/size] 
 
当创建了一个 Socket 套接字后,对于服务器来说,接下来的工作,就是调用 bind(2)为服务器指明
本地址、协议端口号,常常可以看到这样的代码: 
strut sockaddr_in sin; 
 
sin.sin_family = AF_INET; 
sin.sin_addr.s_addr = xxx; 
sin.sin_port = xxx; 
 bind(sock, (struct sockaddr *)&sin, sizeof(sin)); 
 
从这个系统调用中,可以知道当进行 SYS_BIND  操作的时候,: 
1、对于 AF_INET 协议簇来讲,其地址格式是 strut sockaddr_in,而对于 socket 来讲,strut sockaddr 
结构表示的地址格式实现了更高层次 
的抽像,因为每种协议长簇的地址不一定是相同的,所以,系统调用的第三个参数得指明该协议簇
的地址格式的长度。 
 
2、进行 bind(2)系统调用时,除了地址长度外,还得向内核提供:sock 描述符、协议簇名称、本地
地址、端口这些参数; 
 
[size=5][color=Red]2、sys_bind()[/color][/size] 
操作 SYS_BIND  是由 sys_bind()实现的: 
 
asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 

        struct socket *sock; 
        char address[MAX_SOCK_ADDR]; 
        int err; 
 
        if((sock = sockfd_lookup(fd,&err))!=NULL) 
        { 
                if((err=move_addr_to_kernel(umyaddr,addrlen,address))>=0) { 
                        err = security_socket_bind(sock, (struct sockaddr *)address, addrlen); 
                        if (err) { 
                                sockfd_put(sock); 
                                return err; 
                        } 
                        err = sock->ops->bind(sock, (struct sockaddr *)address, addrlen); 
                } 
                sockfd_put(sock); 
        }                         
        return err; 

 
在 socket 的创建中,已经反复分析了 socket 与文件系统的关系,现在已知 socket的描述符号,要找
出与之相关的 socket 结构,应该是件容易的事情: 
 
struct socket *sockfd_lookup(int fd, int *err) 

        struct file *file; 
        struct inode *inode; 
        struct socket *sock; 
         if (!(file = fget(fd))) 
        { 
                *err = -EBADF; 
                return NULL; 
        } 
 
        inode = file->f_dentry->d_inode; 
        if (!S_ISSOCK(inode->i_mode)) { 
                *err = -ENOTSOCK; 
                fput(file); 
                return NULL; 
        } 
 
        sock = SOCKET_I(inode); 
        if (sock->file != file) { 
                printk(KERN_ERR "socki_lookup: socket file changed!/n"); 
                sock->file = file; 
        } 
        return sock; 

 
fget 从当前进程的 files 指针中,根据 sock 对应的描述符号,找到已打开的文件 file,再根据文件的
目录项中的 inode,利用inode 与 sock 被封装在同一个结构中的事实,调用宏 SOCKET_I找到待查
的 sock 结构。最后做一个小小的判断,因为正常情况下,sock 的 file 指针是  回指与之相关的 file。  
 
接下来的工作是把用户态的地址拷贝至内核中来: 
int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr) 

        if(ulen<0||ulen>MAX_SOCK_ADDR) 
                return -EINVAL; 
        if(ulen==0) 
                return 0; 
        if(copy_from_user(kaddr,uaddr,ulen)) 
                return -EFAULT; 
        return 0; 

 
bind(2)第三个参数必须存在的原因之一,copy_from_user 必须知道拷贝的字节长度。 
 
因为 sock 的 ops 函数指针集,在创建之初,就指向了对应的协议类型,例如如果类型是
SOCK_STREAM,那么它就指向 inetsw_array[0].ops。也就是 inet_stream_ops: 
struct proto_ops inet_stream_ops = { 
        .family =        PF_INET, 
        ……         .bind =                inet_bind, 
        …… 
}; 
 
sys_bind()在做完了一个通用的 socket bind 应该做的事情,包括查找对应 sock 结构,拷贝地址。就
调用对应协议族的对应协议类型的 bind 函数,也就是 inet_bind。 
 
[size=5][color=Red]3、inet_bind[/color][/size] 
说 bind(2)的最重要的作用,就是为套接字绑定地址和端口,那么要分析 inet_bind()之前,要搞清楚
的一件事情就是,这个绑定,是绑定到哪儿?或者说,是绑定到内核的哪个数据结构的哪个成员变
量上面?? 
有三个地方是可以考虑的:socket 结构,包括 sock 和 sk,inet结构,以及 protoname_sock 结构。绑
定在 socket 结构上是可行  的,这样可以实现最高层面上的抽像,但是因为每一类协议簇 socket 的
地址及端口表现形式差异很大,这样就得引入专门的转换处理功能。绑定在 protoname_sock 也是
可行的,但是却是最笨拙的,因为例如 tcp 和 udp,它们的地址及端口表现形式是一样的,这样就
浪费了空间,加大了代码  处理量。所以,inet 做为一个协议类型的抽像,是最理想的地方了,再来
回顾一下它的定义: 
 
[code]struct inet_sock { 
        …… 
        /* Socket demultiplex comparisons on incoming packets. */ 
        __u32                        daddr;                /* Foreign IPv4 addr */ 
        __u32                        rcv_saddr;        /* Bound local IPv4 addr */ 
        __u16                         dport;                /* Destination port */ 
        __u16                        num;                /* Local port */ 
        __u32                        saddr;                /* Sending source */ 
        …… 
};[/code] 
 
去掉了其它成员,保留了与地址及端口相关的成员变量,从注释中,可以清楚地了解它们的作用。
所以,我们说的 bind(2)之绑定,主要就是对这几个成员变量赋值的过程了。 
 
[code]int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 

        /*  获取地址参数 */ 
        struct sockaddr_in *addr = (struct sockaddr_in *)uaddr; 
        /*  获取 sock 对应的 sk */ 
        struct sock *sk = sock->sk; 
        /*  获取 sk 对应的inet */ 
        struct inet_sock *inet = inet_sk(sk); 
        /*  这个临时变量用来保存用户态传递下来的端口参数 */ 
        unsigned short snum; 
        int chk_addr_ret; 
        int err;  
        /*  如果协议簇对应的协议自身还有 bind 函数,调用之,例如 SOCK_RAW 就还有一个
raw_bind */ 
        if (sk->sk_prot->bind) { 
                err = sk->sk_prot->bind(sk, uaddr, addr_len); 
                goto out; 
        } 
        /*  校验地址长度 */ 
        err = -EINVAL; 
        if (addr_len < sizeof(struct sockaddr_in)) 
                goto out; 
 
        /*  判断地址类型:广播?多播?单播? */ 
        chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr); 
         
        /* ipv4 有一个 ip_nonlocal_bind标志,表示是否绑定非本地址 IP地址,可以通过  
         * cat /proc/sys/net/ipv4/ip_nonlocal_bind 查看到。它用来解决某些服务绑定 
         *  动态 IP地址的情况。作者在注释中已有详细说明: 
         * Not specified by any standard per-se, however it breaks too 
         * many applications when removed.  It is unfortunate since 
         * allowing applications to make a non-local bind solves 
         * several problems with systems using dynamic addressing. 
         * (ie. your servers still start up even if your ISDN link 
         *  is temporarily down) 
         *  这里判断,用来确认如果没有开启“绑定非本地址 IP”,地址值及类型是正确的 
         */ 
        err = -EADDRNOTAVAIL; 
        if (!sysctl_ip_nonlocal_bind && 
            !inet->freebind && 
            addr->sin_addr.s_addr != INADDR_ANY && 
            chk_addr_ret != RTN_LOCAL && 
            chk_addr_ret != RTN_MULTICAST && 
            chk_addr_ret != RTN_BROADCAST) 
                goto out; 
         
        /*  获取协议端口号 */ 
        snum = ntohs(addr->sin_port); 
        err = -EACCES; 
        /*  校验当前进程有没有使用低于 1024 端口的能力 */ 
        if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 
                goto out; 
 
        /*      We keep a pair of addresses. rcv_saddr is the one 
         *      used by hash lookups, and saddr is used for transmit.          * 
         *      In the BSD API these are the same except where it 
         *      would be illegal to use them (multicast/broadcast) in 
         *      which case the sending device address is used. 
         */ 
        lock_sock(sk); 
 
        /*  检查 socket 是否已经被绑定过了:用了两个检查项,一个是 sk 状态,另一个是是否已经
绑定过端口了 
         当然地址本来就可以为 0,所以,不能做为检查项 */ 
        err = -EINVAL; 
        if (sk->sk_state != TCP_CLOSE || inet->num) 
                goto out_release_sock; 
         
        /*  绑定 inet 的接收地址(地址服务绑定地址)和来源地址为用户态指定地址 */ 
        inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr; 
        /*  若地址类型为广播或多播,则将地址置 0,表示直接使用网络设备 */ 
        if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST) 
                inet->saddr = 0;  /* Use device */ 
 
        /*  
         *  调用协议的 get_port 函数,确认是否可绑定端口,若可以,则绑定在 inet->num 之上,注
意,这里虽然没有 
         *  把inet 传过去,但是第一个参数 sk,它本身和 inet是可以互相转化的 
         */ 
        if (sk->sk_prot->get_port(sk, snum)) { 
                inet->saddr = inet->rcv_saddr = 0; 
                err = -EADDRINUSE; 
                goto out_release_sock; 
        } 
         
        /*  如果端口和地址可以绑定,置标志位 */ 
        if (inet->rcv_saddr) 
                sk->sk_userlocks |= SOCK_BINDADDR_LOCK; 
        if (snum) 
                sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 
        /* inet的 sport(来源端口)成员也置为绑定端口 */ 
        inet->sport = htons(inet->num); 
        inet->daddr = 0; 
        inet->dport = 0; 
        sk_dst_reset(sk); 
        err = 0; 
out_release_sock: 
        release_sock(sk); out: 
        return err; 
}[/code] 
上述分析中,忽略的第一个细节是 capable()函数调用,它是 Linux  安全模块(LSM)的一部份,简单
地讲其用来对权限做出检查, 
检查是否有权对指定的资源进行操作。这里它的参数是 CAP_NET_BIND_SERVICE,表示的含义是:  
[code]/* Allows binding to TCP/UDP sockets below 1024 */ 
/* Allows binding to ATM VCIs below 32 */ 
 
#define CAP_NET_BIND_SERVICE 10[/code] 
 
另一个就是协议的端口绑定,调用了协议的 get_port 函数,如果是 SOCK_STREAM的 TCP  协议,
那么它就是 tcp_v4_get_port()函数。 
 
[size=5][color=Red]4、协议端口的绑定[/color][/size] 
 
要分配这个函数,还是得先绕一些基本的东东。这里涉及到内核中提供 hash 链表的操作的 API。可
以参考其它相关资料。 
[url]http://www.ibm.com/developerworks/cn/linux/kernel/l-chain/index.html[/url] 
这里讲了链表的实现,顺道提了一个 hash 链表,觉得写得还不错,收藏一下。 
 
对于 TCP已注册的端口,是采用一个 hash 表来维护的。hash 桶用 struct tcp_bind_hashbucket 结构来
表示: 
[code]struct tcp_bind_hashbucket { 
        spinlock_t                lock; 
        struct hlist_head        chain; 
};[/code] 
 
hash 表中的每一个 hash节点,用 struct tcp_bind_hashbucket 结构来表示: 
struct tcp_bind_bucket { 
[code]        unsigned short                port;                        /*  节点中绑定的端口 */ 
        signed short                fastreuse; 
        struct hlist_node        node; 
        struct hlist_head        owners; 
};[/code] 
 
tcp_hashinfo 的 hash 表信息,都集中封装在结构 tcp_hashinfo 当中,而维护已注册端口,只是它其
中一部份: 
 
[code]extern struct tcp_hashinfo { 
        …… 
 
        /* Ok, let's try this, I give up, we do need a local binding 
         * TCP hash as well as the others for fast bind/connect.          */ 
        struct tcp_bind_hashbucket *__tcp_bhash; 
 
        int __tcp_bhash_size; 
        …… 
} tcp_hashinfo; 
 
#define tcp_bhash        (tcp_hashinfo.__tcp_bhash) 
#define tcp_bhash_size        (tcp_hashinfo.__tcp_bhash_size)[/code] 
 
其使用的 hash 函数是 tcp_bhashfn: 
[code]/* These are AF independent. */ 
static __inline__ int tcp_bhashfn(__u16 lport) 

        return (lport & (tcp_bhash_size - 1)); 
}[/code] 
 
这样,如果要取得某个端口对应的 hash 链的首部hash 桶节点的话,可以使用: 
[code]struct tcp_bind_hashbucket *head; 
head = &tcp_bhash[tcp_bhashfn(snum)];[/code] 
 
如果要新绑定一个端口,就是先创建一个 struct tcp_bind_hashbucket 结构的 hash 节点,然后把它插
入到对应的 
hash 链中去: 
[code]struct tcp_bind_bucket *tb; 
 
tb = tcp_bucket_create(head, snum); 
 
struct tcp_bind_bucket *tcp_bucket_create(struct tcp_bind_hashbucket *head, 
                                          unsigned short snum) 

        struct tcp_bind_bucket *tb = kmem_cache_alloc(tcp_bucket_cachep, 
                                                      SLAB_ATOMIC); 
        if (tb) { 
                tb->port = snum; 
                tb->fastreuse = 0; 
                INIT_HLIST_HEAD(&tb->owners); 
                hlist_add_head(&tb->node, &head->chain); 
        } 
        return tb; 
}[/code] 
 
另外,sk 中,还级护了一个类似的 hash 链表,同时需要调用 tcp_bind_hash()函数把 hash 节点插入
进去: [code]struct sock { 
        struct sock_common        __sk_common; 
#define sk_bind_node                __sk_common.skc_bind_node 
        …… 
}[/code] 
 
[code]/* @skc_bind_node: bind hash linkage for various protocol lookup tables */ 
struct sock_common { 
        struct hlist_node        skc_bind_node; 
        …… 
}[/code] 
         
[code]if (!tcp_sk(sk)->bind_hash) 
        tcp_bind_hash(sk, tb, snum); 
         
void tcp_bind_hash(struct sock *sk, struct tcp_bind_bucket *tb, 
                   unsigned short snum) 

        inet_sk(sk)->num = snum; 
        sk_add_bind_node(sk, &tb->owners); 
        tcp_sk(sk)->bind_hash = tb; 
}[/code] 
 
这里,就顺道绑定了 inet 的 num成员变量,并置协议的 bind_hash 指针为当前分配的 hash 节点。而
sk_add_bind_node 函数, 
就是一个插入 hash 表节点的过程: 
 
[code]static __inline__ void sk_add_bind_node(struct sock *sk, 
                                        struct hlist_head *list) 

        hlist_add_head(&sk->sk_bind_node, list); 
}[/code] 
 
如果要遍历 hash 表的话,例如在插入之前,先判断端口是否已经在 hash表当中了。就可以调用: 
 
[code]#define tb_for_each(tb, node, head) hlist_for_each_entry(tb, node, head, node) 
 
struct tcp_bind_hashbucket *head; 
struct tcp_bind_bucket *tb; 
 
head = &tcp_bhash[tcp_bhashfn(snum)]; 
spin_lock(&head->lock); 
tb_for_each(tb, node, &head->chain) 
        if (tb->port == snum)                 found,do_something;[/code]                 
有了这些基础知识,再来看 tcp_v4_get_port()的实现,就要容易得多了: 
 
[code]static int tcp_v4_get_port(struct sock *sk, unsigned short snum) 

        struct tcp_bind_hashbucket *head; 
        struct hlist_node *node; 
        struct tcp_bind_bucket *tb; 
        int ret; 
 
        local_bh_disable(); 
         
        /*  如果端口值为 0,意味着让系统从本地可用端口用选择一个,并置 snum为分配的值 */ 
        if (!snum) { 
                int low = sysctl_local_port_range[0]; 
                int high = sysctl_local_port_range[1]; 
                int remaining = (high - low) + 1; 
                int rover; 
 
                spin_lock(&tcp_portalloc_lock); 
                if (tcp_port_rover < low) 
                        rover = low; 
                else 
                        rover = tcp_port_rover; 
                do { 
                        rover++; 
                        if (rover > high) 
                                rover = low; 
                         head = &tcp_bhash[tcp_bhashfn(rover)]; 
                        spin_lock(&head->lock); 
                        tb_for_each(tb, node, &head->chain) 
                                if (tb->port == rover) 
                                        goto next; 
                        break; 
                next: 
                        spin_unlock(&head->lock); 
                } while (--remaining > 0); 
                tcp_port_rover = rover; 
                spin_unlock(&tcp_portalloc_lock); 
 
                /* Exhausted local port range during search? */ 
                ret = 1; 
                if (remaining <= 0) 
                        goto fail;  
                /* OK, here is the one we will use.  HEAD is 
                 * non-NULL and we hold it's mutex. 
                 */ 
                snum = rover; 
        } else { 
                /*  否则,就在 hash 表中,查找端口是否已经存在 */ 
                head = &tcp_bhash[tcp_bhashfn(snum)]; 
                spin_lock(&head->lock); 
                tb_for_each(tb, node, &head->chain) 
                        if (tb->port == snum) 
                                goto tb_found; 
        } 
        tb = NULL; 
        goto tb_not_found; 
tb_found: 
        /*  稍后有对应的代码:第一次分配 tb 后,会调用 tcp_bind_hash加入至相应的 sk,这里先做
一个判断,来确定这一步工作是否进行过*/ 
        if (!hlist_empty(&tb->owners)) { 
/* socket的 SO_REUSEADDR  选项,用来确定是否允许本地地址重用,例如同时启动多个服务器、
多个套接字绑定至同一端口等等, sk_reuse 成员对应其值,因为如果一个绑定的 hash节点已经存在,
而且不允许重用的话,那么则表示因冲突导致出错,调用 tcp_bind_conflict 来处理之 */ 
                if (sk->sk_reuse > 1) 
                        goto success; 
                if (tb->fastreuse > 0 && 
                    sk->sk_reuse && sk->sk_state != TCP_LISTEN) { 
                        goto success; 
                } else { 
                        ret = 1; 
                        if (tcp_bind_conflict(sk, tb)) 
                                goto fail_unlock; 
                } 
        } 
tb_not_found: 
        /*  如果不存在,则分配 hash节点,绑定端口 */ 
        ret = 1; 
        if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL) 
                goto fail_unlock; 
        if (hlist_empty(&tb->owners)) { 
                if (sk->sk_reuse && sk->sk_state != TCP_LISTEN) 
                        tb->fastreuse = 1; 
                else 
                        tb->fastreuse = 0; 
        } else if (tb->fastreuse &&                    (!sk->sk_reuse || sk->sk_state == TCP_LISTEN)) 
                tb->fastreuse = 0; 
success: 
        if (!tcp_sk(sk)->bind_hash) 
                tcp_bind_hash(sk, tb, snum); 
        BUG_TRAP(tcp_sk(sk)->bind_hash == tb); 
        ret = 0; 
 
fail_unlock: 
        spin_unlock(&head->lock); 
fail: 
        local_bh_enable(); 
        return ret; 
}[/code] 
 
到这里,可以为这部份下一个小结了,所谓绑定,就是: 
1、设置内核中 inet 相关变量成员的值,以待后用; 
2、协议中,如 TCP协议,记录绑定的协议端口的信息,采用 hash 链表存储,sk 中也同时维护了这
么一个链表。两者的区别应该是 
前者给协议用。后者给 socket 用。 
 
 
 
 
 
Linux TCP/IP 协议栈之 Scoket实现分析(三 socket的 Listen) 
 
[size=5][color=Red]一、sys_listen[/color][/size] 
 
对面向连接的协议,在调用 bind(2)后,进一步调用 listen(2),让套接字进入监听状态: 
[code]int listen(int sockfd, int backlog);[/code] 
 
backlog 表示新建连接请求时,最大的未处理的积压请求数。 
 
这里说到让套接字进入某种状态,也就是说,涉及到套接字的状态变迁,前面 create 和bind 时,也
遇到过相应的代码。 
 
sock和 sk 都有相应的状态字段,先来看 sock 的: 
[code]typedef enum { 
        SS_FREE = 0,                        /*  套接字未分配                */ 
        SS_UNCONNECTED,                        /*  套接字未连接        */ 
        SS_CONNECTING,                        /*  套接字正在处理连接        */ 
        SS_CONNECTED,                        /*  套接字已连接                */ 
        SS_DISCONNECTING                /*  套接字正在处理关闭连接 */ } socket_state;[/code] 
 
在创建套接字时,被初始化为 SS_UNCONNECTED。 
 
对于面向连接模式的SOCK_TREAM来讲,这样描述状态显然是不够的。 这样, 在sk中, 使用sk_state
维护了一个有限状态机来描述套接字的状态: 
[code]enum { 
  TCP_ESTABLISHED = 1, 
  TCP_SYN_SENT, 
  TCP_SYN_RECV, 
  TCP_FIN_WAIT1, 
  TCP_FIN_WAIT2, 
  TCP_TIME_WAIT, 
  TCP_CLOSE, 
  TCP_CLOSE_WAIT, 
  TCP_LAST_ACK, 
  TCP_LISTEN, 
  TCP_CLOSING,         /* now a valid state */ 
 
  TCP_MAX_STATES /* Leave at the end! */ 
};[/code] 
 
还有一个相应的用来进行状态位运算的枚举结构: 
[code]enum { 
  TCPF_ESTABLISHED = (1 << 1), 
  TCPF_SYN_SENT  = (1 << 2), 
  TCPF_SYN_RECV  = (1 << 3), 
  TCPF_FIN_WAIT1 = (1 << 4), 
  TCPF_FIN_WAIT2 = (1 << 5), 
  TCPF_TIME_WAIT = (1 << 6), 
  TCPF_CLOSE     = (1 << 7), 
  TCPF_CLOSE_WAIT = (1 << 8), 
  TCPF_LAST_ACK  = (1 << 9), 
  TCPF_LISTEN    = (1 << 10), 
  TCPF_CLOSING   = (1 << 11)  
};[/code] 
 
值得一提的是,sk 的状态不等于 TCP的状态,虽然 sk 是面向协议栈,但它的状态并不能同 TCP状
态一一直接划等号。虽然这些状态值都用 TCP-XXX 来表式,但是只是因为 TCP协议状态非常复杂。
sk 结构只是利用它的一个子集来抽像描述而已。 
 
同样地,操作码 SYS_LISTEN的任务会落到 sys_listen()函数身上: 
[code] 
/* Maximum queue length specifiable by listen.  */ #define SOMAXCONN        128 
int sysctl_somaxconn = SOMAXCONN; 
 
asmlinkage long sys_listen(int fd, int backlog) 

        struct socket *sock; 
        int err; 
         
        if ((sock = sockfd_lookup(fd, &err)) != NULL) { 
                if ((unsigned) backlog > sysctl_somaxconn) 
                        backlog = sysctl_somaxconn; 
 
                err = security_socket_listen(sock, backlog); 
                if (err) { 
                        sockfd_put(sock); 
                        return err; 
                } 
 
                err=sock->ops->listen(sock, backlog); 
                sockfd_put(sock); 
        } 
        return err; 
}[/code] 
 
同样地,函数会最终转向协议簇的 listen 函数,也就是 inet_listen(): 
 
[code]/* 
*        Move a socket into listening state. 
*/ 
int inet_listen(struct socket *sock, int backlog) 

        struct sock *sk = sock->sk; 
        unsigned char old_state; 
        int err; 
 
        lock_sock(sk); 
 
        err = -EINVAL; 
        /* 在 listen 之前,sock 必须为未连接状态,且只有 SOCK_STREAM 类型,才有 listen(2)*/ 
        if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM) 
                goto out; 
 
        /*  临时保存状态机状态 */ 
        old_state = sk->sk_state;         /*  只有状态机处于 TCP_CLOSE  或者是 TCP_LISTEN  这两种状态时,才可能对其调用
listen(2)  ,这个判断证明了 listen(2)是可以重复调用地(当然是在转向 TCP_LISTEN 后没有再进行
状态变迁*/ 
        if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN))) 
                goto out; 
 
        /*  如果接口已经处理 listen 状态,只修改其 max_backlog,否则先调用 tcp_listen_start,继续
设置协议的 listen 状态 
         */ 
        if (old_state != TCP_LISTEN) { 
                err = tcp_listen_start(sk); 
                if (err) 
                        goto out; 
        } 
        sk->sk_max_ack_backlog = backlog; 
        err = 0; 
 
out: 
        release_sock(sk); 
        return err; 
}[/code] 
 
inet_listen 函数在确认 sock->state 和 sk->sk_state 状态后,会进一步调用 tcp_listen_start 函数,最且
最后设置 sk_max_ack_backlog  。 
 
tcp 的 tcp_listen_start 函数,完成两个重要的功能,一个是初始化 sk 的一些相关成员变量,另一方
面是切换有限状态机的状态。 sk_max_ack_backlog表示监听时最大的 backlog 数量,它由用户空间
传递的参数决定。而 sk_ack_backlog表示当前的的 backlog数量。 
 
当 tcp 服务器收到一个 syn 报文时,它表示了一个连接请求的到达。内核使用了一个 hash 表来维护
这个连接请求表: 
struct tcp_listen_opt 

        u8                        max_qlen_log;        /* log_2 of maximal queued SYNs */ 
        int                        qlen; 
        int                        qlen_young; 
        int                        clock_hand; 
        u32                        hash_rnd; 
        struct open_request        *syn_table[TCP_SYNQ_HSIZE]; 
}; 
 
syn_table,  是open_request结构,就是连接请求表,连中的最大项,也就是最大允许的 syn 报文的数
量,由 max_qlen_log 来决定。当套接字进入 listen 状态,也就是说可以接收 syn 报文了,那么在此
之前,需要先初始化这个表:  
[code] 
int tcp_listen_start(struct sock *sk) 

        struct inet_sock *inet = inet_sk(sk);                //获取 inet结构指针 
        struct tcp_sock *tp = tcp_sk(sk);                //获取协议指针 
        struct tcp_listen_opt *lopt; 
         
        //初始化 sk 相关成员变量 
        sk->sk_max_ack_backlog = 0; 
        sk->sk_ack_backlog = 0; 
         
        tp->accept_queue = tp->accept_queue_tail = NULL; 
        rwlock_init(&tp->syn_wait_lock); 
        tcp_delack_init(tp); 
         
        //初始化连接请求 hash 表 
        lopt = kmalloc(sizeof(struct tcp_listen_opt), GFP_KERNEL); 
        if (!lopt) 
                return -ENOMEM; 
 
        memset(lopt, 0, sizeof(struct tcp_listen_opt)); 
        //初始化 hash 表容量,最小为 6,其实际值由 sysctl_max_syn_backlog 决定 
        for (lopt->max_qlen_log = 6; ; lopt->max_qlen_log++) 
                if ((1 << lopt->max_qlen_log) >= sysctl_max_syn_backlog) 
                        break; 
        get_random_bytes(&lopt->hash_rnd, 4); 
 
        write_lock_bh(&tp->syn_wait_lock); 
        tp->listen_opt = lopt; 
        write_unlock_bh(&tp->syn_wait_lock); 
 
        /* There is race window here: we announce ourselves listening, 
         * but this transition is still not validated by get_port(). 
         * It is OK, because this socket enters to hash table only 
         * after validation is complete. 
         */ 
         /*  修改状态机状态,表示进入 listen 状态,根据作者注释,当宣告自己进入 listening 状态后,
但是这个状态转换并没有得到 get_port 的确  认。所以需要调用 get_port()函数。但是对于一点,暂
时还没有完全搞明白,只有留待后面再来分析它 */ 
        sk->sk_state = TCP_LISTEN; 
        if (!sk->sk_prot->get_port(sk, inet->num)) { 
                inet->sport = htons(inet->num); 
                 sk_dst_reset(sk); 
                sk->sk_prot->hash(sk); 
 
                return 0; 
        } 
 
        sk->sk_state = TCP_CLOSE; 
        write_lock_bh(&tp->syn_wait_lock); 
        tp->listen_opt = NULL; 
        write_unlock_bh(&tp->syn_wait_lock); 
        kfree(lopt); 
        return -EADDRINUSE; 
}[/code] 
 
在切换了有限状态机状态后,调用了 
[code]sk->sk_prot->hash(sk);[/code] 
也就是 tcp_v4_hash()函数。这里涉到到另一个 hash 表:TCP监听 hash 表。 
 
[size=5][color=Red]二、TCP监听 hash表[/color][/size] 
所谓 TCP 监听表,指的就内核维护“当前有哪些套接字在监听”的一个表,当一个数据包进入 TCP
栈的时候,内核查询这个表中对应的 sk,以找到相应的数据  结构。 (因为 sk 是面向网络栈调用的,
找到了 sk,就找到了 tcp_sock,就找到了 inet_sock,就找到了 sock,就找到了 fd……就到了组  织
了)。 
 
TCP所有的 hash 表都用了tcp_hashinfo来封装,前面分析 bind已见过它: 
[code]extern struct tcp_hashinfo { 
                 …… 
        /* All sockets in TCP_LISTEN state will be in here.  This is the only 
         * table where wildcard'd TCP sockets can exist.  Hash function here 
         * is just local port number. 
         */ 
        struct hlist_head __tcp_listening_hash[TCP_LHTABLE_SIZE]; 
 
                 …… 
        spinlock_t __tcp_portalloc_lock; 
} tcp_hashinfo; 
 
#define tcp_listening_hash (tcp_hashinfo.__tcp_listening_hash)[/code] 
 
函数 tcp_v4_hash 将一个处理监听状态下的 sk 加入至这个 hash 表: 
[code]static void tcp_v4_hash(struct sock *sk) 

        if (sk->sk_state != TCP_CLOSE) { 
                local_bh_disable();                 __tcp_v4_hash(sk, 1); 
                local_bh_enable(); 
        } 
}[/code] 
 
因为__tcp_v4_hash 不只用于监听 hash 表,它也用于其它 hash 表,其第二个参数 listen_possible 为
真的时候,表示处理的是监听 hash表: 
[code]static __inline__ void __tcp_v4_hash(struct sock *sk, const int listen_possible) 

        struct hlist_head *list; 
        rwlock_t *lock; 
 
        BUG_TRAP(sk_unhashed(sk)); 
        if (listen_possible && sk->sk_state == TCP_LISTEN) { 
                list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)]; 
                lock = &tcp_lhash_lock; 
                tcp_listen_wlock(); 
        } else { 
                                …… 
        } 
        __sk_add_node(sk, list); 
        sock_prot_inc_use(sk->sk_prot); 
        write_unlock(lock); 
        if (listen_possible && sk->sk_state == TCP_LISTEN) 
                wake_up(&tcp_lhash_wait); 
}[/code] 
else 中的部份用于另一个 hash 表,暂时不管它。代表很简单,如果确认是处理的是监听 hash 表。
则先根据 sk计算一个 hash 值,在hash 桶中找到入口。再调用__sk_add_node 加入至该 hash 链。 
 
tcp_sk_listen_hashfn()函数事实上是 tcp_lhashfn 的包裹,前面已经分析过了。 
 
__sk_add_node()函数也就是一个简单的内核 hash处理函数 hlist_add_head()的包裹: 
[code]static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list) 

        hlist_add_head(&sk->sk_node, list); 
}[/code] 
 
小结 
 
一个套接字的 listen,主要需要做的工作有以下几件: 
1、初始化 sk 相关的成员变量,最重要的是 listen_opt,也就是连接请求 hash 表。 
2、将 sk 的有限状态机转换为 TCP_LISTEN,即监听状态; 
3、将 sk 加入监听 hash表; 
4、设置允许的最大请求积压数,也就是 sk 的成员 sk_max_ack_backlog 的值。  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Linux TCP/IP 协议栈之 Socket的实现分析(四 Accept 接受一个连接) 
 
[color=Red][size=5]一、tcp 栈的三次握手简述[/size][/color] 
 
进一步的分析,都是以 tcp 协议为例,因为 udp要相对简单得多,分析完 tcp,udp的基本已经被覆
盖了。 
 
这里主要是分析 socket,但是因为它将与 tcp/udp传输层交互,所以不可避免地接触到这一层面的代
码,这里只是摘取其主要流程的一些代码片段,以更好地分析 accept的实现过程。 
 
当套接字进入 LISTEN后,意味着服务器端已经可以接收来自客户端的请求。当一个 syn 包到达后,
服务器认为它是一个 tcp  请求报文,根据 tcp 
协议,TCP 网络栈将会自动应答它一个 syn+ack 报文,并且将它放入 syn_table 这个 hash 表中,静
静地等待客户端第三次握手报文的来到。一个 tcp 的 syn 报文进入 tcp 堆栈后,会按以下函数调用,
最终进入 tcp_v4_conn_request: 
 
[code]tcp_v4_rcv 
        ->tcp_v4_do_rcv 
                ->tcp_rcv_state_process 
                        ->tp->af_specific->conn_request[/code] 
 tcp_ipv4.c 中,tcp_v4_init_sock 初始化时,有 
 
tp->af_specific = &ipv4_specific; 
 
[code]struct tcp_func ipv4_specific = { 
        .queue_xmit        =        ip_queue_xmit, 
        .send_check        =        tcp_v4_send_check, 
        .rebuild_header        =        tcp_v4_rebuild_header, 
        .conn_request        =        tcp_v4_conn_request, 
        .syn_recv_sock        =        tcp_v4_syn_recv_sock, 
        .remember_stamp        =        tcp_v4_remember_stamp, 
        .net_header_len        =        sizeof(struct iphdr), 
        .setsockopt        =        ip_setsockopt, 
        .getsockopt        =        ip_getsockopt, 
        .addr2sockaddr        =        v4_addr2sockaddr, 
        .sockaddr_len        =        sizeof(struct sockaddr_in), 
};[/code] 
 
所以 af_specific->conn_request实际指向的是 tcp_v4_conn_request: 
 
[code]int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb) 

        struct open_request *req; 
        …… 
        /*  分配一个连接请求 */ 
        req = tcp_openreq_alloc(); 
        if (!req) 
                goto drop; 
        ……         
        /*  根据数据包的实际要素,如来源/目的地址等,初始化它*/ 
        tcp_openreq_init(req, &tmp_opt, skb); 
 
        req->af.v4_req.loc_addr = daddr; 
        req->af.v4_req.rmt_addr = saddr; 
        req->af.v4_req.opt = tcp_v4_save_options(sk, skb); 
        req->class = &or_ipv4;                 
        …… 
        /*  回送一个 syn+ack 的二次握手报文 */ 
        if (tcp_v4_send_synack(sk, req, dst)) 
                goto drop_and_free; 
 
        if (want_cookie) { 
                …… 
        } else {                 /*  将连接请求 req 加入连接监听表 syn_table */ 
                tcp_v4_synq_add(sk, req); 
        } 
        return 0;         
}[/code] 
 
syn_table 在前面分析的时候已经反复看到了。它的作用就是记录 syn 请求报文,构建一个 hash 表。
这里调用的 tcp_v4_synq_add()就完成了将请求添加进该表的操作: 
[code] 
static void tcp_v4_synq_add(struct sock *sk, struct open_request *req) 

        struct tcp_sock *tp = tcp_sk(sk); 
        struct tcp_listen_opt *lopt = tp->listen_opt; 
        /*  计算一个 hash值 */ 
        u32 h = tcp_v4_synq_hash(req->af.v4_req.rmt_addr, req->rmt_port, lopt->hash_rnd); 
 
        req->expires = jiffies + TCP_TIMEOUT_INIT; 
        req->retrans = 0; 
        req->sk = NULL; 
        /*指针移到 hash 链的未尾*/ 
        req->dl_next = lopt->syn_table[h]; 
 
        write_lock(&tp->syn_wait_lock); 
        /*加入当前节点*/ 
        lopt->syn_table[h] = req; 
        write_unlock(&tp->syn_wait_lock); 
 
        tcp_synq_added(sk); 
}[/code] 
 
这样,所以的 syn 请求都被放入这个表中,留待第三次 ack 的到来的匹配。当第三次 ack 来到后,
会进入下列函数: 
[code]tcp_v4_rcv 
        ->tcp_v4_do_rcv[/code] 
 
[code]int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb) 

        …… 
         
        if (sk->sk_state == TCP_LISTEN) { 
                struct sock *nsk = tcp_v4_hnd_req(sk, skb); 
        …… 
}[/code] 
 因为目前 sk还是 TCP_LISTEN状态,所以会进入 tcp_v4_hnd_req: 
[code]static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb) 

        struct tcphdr *th = skb->h.th; 
        struct iphdr *iph = skb->nh.iph; 
        struct tcp_sock *tp = tcp_sk(sk); 
        struct sock *nsk; 
        struct open_request **prev; 
        /* Find possible connection requests. */ 
        struct open_request *req = tcp_v4_search_req(tp, &prev, th->source, 
                                                     iph->saddr, iph->daddr); 
        if (req) 
                return tcp_check_req(sk, skb, req, prev); 
        …… 
}[/code] 
 
tcp_v4_search_req 就是查找匹配 syn_table 表: 
[code]static struct open_request *tcp_v4_search_req(struct tcp_sock *tp, 
                                              struct open_request ***prevp, 
                                              __u16 rport, 
                                              __u32 raddr, __u32 laddr) 

        struct tcp_listen_opt *lopt = tp->listen_opt; 
        struct open_request *req, **prev; 
 
        for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)]; 
             (req = *prev) != NULL; 
             prev = &req->dl_next) { 
                if (req->rmt_port == rport && 
                    req->af.v4_req.rmt_addr == raddr && 
                    req->af.v4_req.loc_addr == laddr && 
                    TCP_INET_FAMILY(req->class->family)) { 
                        BUG_TRAP(!req->sk); 
                        *prevp = prev; 
                        break; 
                } 
        } 
 
        return req; 
}[/code] 
 
hash 表的查找还是比较简单的,调用 tcp_v4_synq_hash 计算出 hash 值,找到 hash 链入口,遍历该
链即可。 
 排除超时等意外因素,刚才加入 hash 表的 req 会被找到,这样,tcp_check_req()函数将会被继续调
用: 
[code]struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb, 
                           struct open_request *req, 
                           struct open_request **prev) 

        …… 
        tcp_acceptq_queue(sk, req, child); 
        …… 
}[/code] 
 
req 被找到,表明三次握手已经完成,连接已经成功建立,tcp_check_req 最终将调用
tcp_acceptq_queue(),把这个建立好的连接加入至 tp->accept_queue 队列,等待用户调用 accept(2)来
读取之。 
 
[code]static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req, 
                                         struct sock *child) 

        struct tcp_sock *tp = tcp_sk(sk); 
 
        req->sk = child; 
        sk_acceptq_added(sk); 
 
        if (!tp->accept_queue_tail) { 
                tp->accept_queue = req; 
        } else { 
                tp->accept_queue_tail->dl_next = req; 
        } 
        tp->accept_queue_tail = req; 
        req->dl_next = NULL; 
}[/code] 
 
[size=5][color=Red]二、sys_accept[/color][/size] 
如上,当 listen(2)调用准备就绪的时候,服务器可以通过调用 accept(2)接受或等待(注意这个“或等
待”是相当的重要)连接队列中的第一个请求: 
[code]int accept(int s, struct sockaddr * addr ,socklen_t *addrlen);[/code] 
 
accept(2)调用,只是针对有连接模式。socket 一旦经过 listen(2)调用进入监听状态后,就被动地调用
accept(2),接受来自客  户端的连接请求。accept(2)调用是阻塞的,也就是说如果没有连接请求到达,
它会去睡觉,等到连接请求到来后(或者是超时),才会返回。同样地,操  作码 SYS_ACCEPT 对
应的是函数 sys_accept: 
 
[code]asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user 
*upeer_addrlen) { 
        struct socket *sock, *newsock; 
        int err, len; 
        char address[MAX_SOCK_ADDR]; 
 
        sock = sockfd_lookup(fd, &err); 
        if (!sock) 
                goto out; 
 
        err = -ENFILE; 
        if (!(newsock = sock_alloc()))  
                goto out_put; 
 
        newsock->type = sock->type; 
        newsock->ops = sock->ops; 
 
        err = security_socket_accept(sock, newsock); 
        if (err) 
                goto out_release; 
 
        /* 
         * We don't need try_module_get here, as the listening socket (sock) 
         * has the protocol module (sock->ops->owner) held. 
         */ 
        __module_get(newsock->ops->owner); 
 
        err = sock->ops->accept(sock, newsock, sock->file->f_flags); 
        if (err < 0) 
                goto out_release; 
 
        if (upeer_sockaddr) { 
                if(newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 2)<0) { 
                        err = -ECONNABORTED; 
                        goto out_release; 
                } 
                err = move_addr_to_user(address, len, upeer_sockaddr, upeer_addrlen); 
                if (err < 0) 
                        goto out_release; 
        } 
 
        /* File flags are not inherited via accept() unlike another OSes. */ 
 
        if ((err = sock_map_fd(newsock)) < 0) 
                goto out_release;  
        security_socket_post_accept(sock, newsock); 
 
out_put: 
        sockfd_put(sock); 
out: 
        return err; 
out_release: 
        sock_release(newsock); 
        goto out_put; 
}[/code] 
 
代码稍长了点,逐步来分析它。 
 
一个 socket,经过 listen(2)设置成 server 套接字后,就永远不会再与任何客户端套接字建立连接了。
因为一旦它接受了一个连接请求,就会  创建出一个新的 socket,新的 socket 用来描述新到达的连
接,而原先的 server套接字并无改变,并且还可以通过下一次 accept(2)调用  再创建一个新的出来,
就像母鸡下蛋一样,“只取蛋,不杀鸡”,server 套接字永远保持接受新的连接请求的能力。 
 
函数先通过 sockfd_lookup(),根据 fd,找到对应的 sock,然后通过 sock_alloc分配一个新的 sock。
接着就调用协议簇的 accept()函数: 
[code]/* 
*        Accept a pending connection. The TCP layer now gives BSD semantics. 
*/ 
 
int inet_accept(struct socket *sock, struct socket *newsock, int flags) 

        struct sock *sk1 = sock->sk; 
        int err = -EINVAL; 
        struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err); 
 
        if (!sk2) 
                goto do_err; 
 
        lock_sock(sk2); 
 
        BUG_TRAP((1 << sk2->sk_state) & 
                 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE)); 
 
        sock_graft(sk2, newsock); 
 
        newsock->state = SS_CONNECTED; 
        err = 0; 
        release_sock(sk2); do_err: 
        return err; 
}[/code] 
 
函数第一步工作是调用协议的 accept 函数,然后调用 sock_graft()函数,接下来,设置新的套接字的
状态为 SS_CONNECTED。 
 
[code]/* 
*        This will accept the next outstanding connection. 
*/ 
 
struct sock *tcp_accept(struct sock *sk, int flags, int *err) 

        struct tcp_sock *tp = tcp_sk(sk); 
        struct open_request *req; 
        struct sock *newsk; 
        int error; 
 
        lock_sock(sk); 
 
        /* We need to make sure that this socket is listening, 
         * and that it has something pending. 
         */ 
        error = -EINVAL; 
        if (sk->sk_state != TCP_LISTEN) 
                goto out; 
 
        /* Find already established connection */ 
        if (!tp->accept_queue) { 
                long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 
 
                /* If this is a non blocking socket don't sleep */ 
                error = -EAGAIN; 
                if (!timeo) 
                        goto out; 
 
                error = wait_for_connect(sk, timeo); 
                if (error) 
                        goto out; 
        } 
 
        req = tp->accept_queue; 
        if ((tp->accept_queue = req->dl_next) == NULL) 
                tp->accept_queue_tail = NULL;  
        newsk = req->sk; 
        sk_acceptq_removed(sk); 
        tcp_openreq_fastfree(req); 
        BUG_TRAP(newsk->sk_state != TCP_SYN_RECV); 
        release_sock(sk); 
        return newsk; 
 
out: 
        release_sock(sk); 
        *err = error; 
        return NULL; 
}[/code] 
 
tcp_accept()函数,当发现 tp->accept_queue 准备就绪后,就直接调用 
[code]        req = tp->accept_queue; 
        if ((tp->accept_queue = req->dl_next) == NULL) 
                tp->accept_queue_tail = NULL; 
 
        newsk = req->sk;[/code] 
出队,并取得相应的 sk。 
否则,就在获取超时时间后,调用 wait_for_connect 等待连接的到来。这也是说,强调“或等待”的
原因所在了。 
 
OK,继续回到 inet_accept 中来,当取得一个就绪的连接的 sk(sk2)后,先校验其状态,再调用
sock_graft()函数。 
 
在 sys_accept 中,已经调用了 sock_alloc,分配了一个新的 socket 结构(即 newsock),但 sock_alloc
必竟不是 sock_create,它并不能为 newsock 分配一个对应的 sk。所以这个套接字并不完整。 
另一方面,当一个连接到达到,根据客户端的请求,产生了一个新的 sk(即 sk2,但这个分配过程
没有深入 tcp 栈去分析其实现,只分析了它对应的 req 入队的代码)。呵呵,将两者一关联,就 OK
了,这就是 sock_graft 的任务: 
[code]static inline void sock_graft(struct sock *sk, struct socket *parent) 

        write_lock_bh(&sk->sk_callback_lock); 
        sk->sk_sleep = &parent->wait; 
        parent->sk = sk; 
        sk->sk_socket = parent; 
        write_unlock_bh(&sk->sk_callback_lock); 
}[/code] 
这样,一对一的联系就建立起来了。这个为 accept 分配的新的 socket 也大功告成了。接下来将其状
态切换为 SS_CONNECTED,表示已连接就绪,可以来读取数据了——如果有的话。 
 
顺便提一下,新的 sk 的分配,是在: ]tcp_v4_rcv 
        ->tcp_v4_do_rcv 
                     ->tcp_check_req 
                              ->tp->af_specific->syn_recv_sock(sk, skb, req, NULL); 
即 tcp_v4_syn_recv_sock函数,其又调用 tcp_create_openreq_child()来分配的。 
[code]struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req, struct sk_buff *skb) 

        /* allocate the newsk from the same slab of the master sock, 
         * if not, at sk_free time we'll try to free it from the wrong 
         * slabcache (i.e. is it TCPv4 or v6?), this is handled thru sk->sk_prot -acme */ 
        struct sock *newsk = sk_alloc(PF_INET, GFP_ATOMIC, sk->sk_prot, 0); 
 
        if(newsk != NULL) { 
                          …… 
                         memcpy(newsk, sk, sizeof(struct tcp_sock)); 
                         newsk->sk_state = TCP_SYN_RECV; 
                          …… 
}[/code] 
等到分析 tcp 栈的实现的时候,再来仔细分析它。但是这里新的 sk 的有限状态机被切换至了 
TCP_SYN_RECV(按我的想法,似乎应进入 establshed 才对呀,是不是哪儿看漏了,只有看了后头
的代码再来印证了) 
 
回到 sys_accept 中来,如果调用者要求返回各户端的地址,则调用新的 sk 的getname 函数指针,也
就是 inet_getname: 
[code]/* 
*        This does both peername and sockname. 
*/ 
int inet_getname(struct socket *sock, struct sockaddr *uaddr, 
                        int *uaddr_len, int peer) 

        struct sock *sk                = sock->sk; 
        struct inet_sock *inet        = inet_sk(sk); 
        struct sockaddr_in *sin        = (struct sockaddr_in *)uaddr; 
 
        sin->sin_family = AF_INET; 
        if (peer) { 
                if (!inet->dport || 
                    (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) && 
                     peer == 1)) 
                        return -ENOTCONN; 
                sin->sin_port = inet->dport; 
                sin->sin_addr.s_addr = inet->daddr; 
        } else { 
                __u32 addr = inet->rcv_saddr;                 if (!addr) 
                        addr = inet->saddr; 
                sin->sin_port = inet->sport; 
                sin->sin_addr.s_addr = addr; 
        } 
        memset(sin->sin_zero, 0, sizeof(sin->sin_zero)); 
        *uaddr_len = sizeof(*sin); 
        return 0; 
}[/code] 
 
函数的工作是构建珍上 struct sockaddr_in  结构出来,接着在 sys_accept中,调用 move_addr_to_user()
函数来拷贝至用户空间: 
[code]int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen) 

        int err; 
        int len; 
 
        if((err=get_user(len, ulen))) 
                return err; 
        if(len>klen) 
                len=klen; 
        if(len<0 || len> MAX_SOCK_ADDR) 
                return -EINVAL; 
        if(len) 
        { 
                 if(copy_to_user(uaddr,kaddr,len)) 
                        return -EFAULT; 
        } 
        /* 
         *        "fromlen shall refer to the value before truncation.." 
         *                        1003.1g 
         */ 
        return __put_user(klen, ulen); 
}[/code] 
也就是调用 copy_to_user的过程了。 
 
sys_accept 的最后一步工作,是将新的 socket 结构,与文件系统挂钩: 
[code]        if ((err = sock_map_fd(newsock)) < 0) 
                goto out_release;[/code] 
 
函数 sock_map_fd 在创建 socket 中已经见过了。 
 
小结: 
accept 有几件事情要做 1、要 accept,需要三次握手完成,连接请求入 tp->accept_queue 队列(新为客户端分析的 sk,也在
其中),其才能出队; 
2、为 accept分配一个 sokcet 结构,并将其与新的 sk 关联; 
3、如果调用时,需要获取客户端地址,即第二个参数不为 NULL,则从新的 sk 中,取得其想的葫
芦; 
4、将新的 socket 结构与文件系统挂钩; 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Linux TCP/IP 协议栈之 Socket的实现分析(五 Connect客户端发起连接请求) 
 
[color=Red][size=5]1、sys_connect[/size][/color] 
 
对于客户端来说,当创建了一个套接字后,就可以连接它了。 
[code]                case SYS_CONNECT: 
                        err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 
                        break;[/code] 
 
[code]asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen) 

        struct socket *sock; 
        char address[MAX_SOCK_ADDR]; 
        int err; 
 
        sock = sockfd_lookup(fd, &err); 
        if (!sock) 
                goto out; 
        err = move_addr_to_kernel(uservaddr, addrlen, address); 
        if (err < 0) 
                goto out_put; 
 
        err = security_socket_connect(sock, (struct sockaddr *)address, addrlen); 
        if (err)                 goto out_put; 
 
        err = sock->ops->connect(sock, (struct sockaddr *) address, addrlen, 
                                 sock->file->f_flags); 
out_put: 
        sockfd_put(sock); 
out: 
        return err; 
}[/code] 
 
跟其它操作类似,sys_connect 接着调用 inet_connect: 
 
[code]/* 
*        Connect to a remote host. There is regrettably still a little 
*        TCP 'magic' in here. 
*/ 
int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr, 
                        int addr_len, int flags) 

        struct sock *sk = sock->sk; 
        int err; 
        long timeo; 
 
        lock_sock(sk); 
 
        if (uaddr->sa_family == AF_UNSPEC) { 
                err = sk->sk_prot->disconnect(sk, flags); 
                sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED; 
                goto out; 
        }[/code] 
 
提交的协议簇不正确,则断开连接。 
 
[code]        switch (sock->state) { 
        default: 
                err = -EINVAL; 
                goto out; 
        case SS_CONNECTED: 
                err = -EISCONN; 
                goto out; 
        case SS_CONNECTING: 
                err = -EALREADY; 
                /* Fall out of switch with err, set for this state */ 
                break;[/code] socket 处于不正确的连接状态,返回相应的错误值。 
 
[code]        case SS_UNCONNECTED: 
                err = -EISCONN; 
                if (sk->sk_state != TCP_CLOSE) 
                        goto out; 
                /*调用协议的连接函数*/ 
                err = sk->sk_prot->connect(sk, uaddr, addr_len); 
                if (err < 0) 
                        goto out; 
                /*协议方面的工作已经处理完成了,但是自己的一切工作还没有完成,所以切换至正
在连接中*/ 
                  sock->state = SS_CONNECTING; 
 
                /* Just entered SS_CONNECTING state; the only 
                 * difference is that return value in non-blocking 
                 * case is EINPROGRESS, rather than EALREADY. 
                 */ 
                err = -EINPROGRESS; 
                break; 
        }[/code] 
 
对于 TCP的实际的连接,是通过调用 tcp_v4_connect()函数来实现的。 
 
[size=5][color=Red]二、tcp_v4_connect函数[/color][/size] 
对于 TCP 协议来说,其连接,实际上就是发送一个 SYN 报文,在服务器的应到到来时,回答它一
个 ack 报文,也就是完成三次握手中的第一和第三次。 
 
要发送 SYN 报文,也就是说,需要有完整的来源/目的地址,来源/目的端口,目的地址/端口由用户
态提交,但是问题是没有自己的地址和端口,因为并没有调  用过 bind(2),一台主机,对于端口,
可以像 sys_bind()那样,从本地未用端口中动态分配一个,那地址呢?因为一台主机可能会存在多
个 IP地  址,如果随机动态选择,那么有可能选择一个错误的来源地址,将不能正确地到达目的地
址。换句话说,来源地址的选择,是与路由相关的。 
 
调用路由查找的核心函数 ip_route_output_slow(),在没有提供来源地址的情况下,会根据实际情况,
调用 inet_select_addr()函数来选择一个合适的。同时,如果路由查找命中,会生成一个相应的路由
缓存项,这个缓存项,不但对当前发送 SYN 报  文有意义,对于后续的所有数据包,都可以起到一
个加速路由查找的作用。这一任务,是通过 ip_route_connect()函数完成的,它返回相应的路由缓存
项(也就是说,来源地址也在其中了): 
 
[code]static inline int ip_route_connect(struct rtable **rp, u32 dst, 
                                   u32 src, u32 tos, int oif, u8 protocol, 
                                   u16 sport, u16 dport, struct sock *sk) 
{         struct flowi fl = { .oif = oif, 
                            .nl_u = { .ip4_u = { .daddr = dst, 
                                                 .saddr = src, 
                                                 .tos   = tos } }, 
                            .proto = protocol, 
                            .uli_u = { .ports = 
                                       { .sport = sport, 
                                         .dport = dport } } }; 
 
        int err; 
        if (!dst || !src) { 
                err = __ip_route_output_key(rp, &fl); 
                if (err) 
                        return err; 
                fl.fl4_dst = (*rp)->rt_dst; 
                fl.fl4_src = (*rp)->rt_src; 
                ip_rt_put(*rp); 
                *rp = NULL; 
        } 
        return ip_route_output_flow(rp, &fl, sk, 0); 
}[/code] 
 
首先,构建一个搜索 key fl,在搜索要素中,来源地址/端口是不存在的。所以,当通过
__ip_route_output_key 进行查找时,第一次是不会命中缓存的。 __ip_route_output_key 将继续调用
ip_route_output_slow()函数,在路由表中搜索,并返回一个合适的来源地址,  并且生成一个路由缓
存项。 
路由查找的更多细节,我会在另一个贴子中来分析。 
 
[code]/* This will initiate an outgoing connection. */ 
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len) 

        struct inet_sock *inet = inet_sk(sk); 
        struct tcp_sock *tp = tcp_sk(sk); 
        struct sockaddr_in *usin = (struct sockaddr_in *)uaddr; 
        struct rtable *rt; 
        u32 daddr, nexthop; 
        int tmp; 
        int err; 
 
        if (addr_len < sizeof(struct sockaddr_in)) 
                return -EINVAL; 
 
        if (usin->sin_family != AF_INET) 
                return -EAFNOSUPPORT;[/code] 校验地址长度和协议簇。 
 
[code]nexthop = daddr = usin->sin_addr.s_addr;[/code] 
将下一跳地址和目的地址的临时变量都暂时设为用户提交的地址。 
 
[code]        if (inet->opt && inet->opt->srr) { 
                if (!daddr) 
                        return -EINVAL; 
                nexthop = inet->opt->faddr; 
        }[/code] 
如果使用了来源地址路由,选择一个合适的下一跳地址。 
 
[code]        tmp = ip_route_connect(&rt, nexthop, inet->saddr, 
                               RT_CONN_FLAGS(sk), sk->sk_bound_dev_if, 
                               IPPROTO_TCP, 
                               inet->sport, usin->sin_port, sk); 
        if (tmp < 0) 
                return tmp; 
 
        if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) { 
                ip_rt_put(rt); 
                return -ENETUNREACH; 
        }[/code] 
进行路由查找,并校验返回的路由的类型,TCP是不被允许使用多播和广播的。 
 
[code]        if (!inet->opt || !inet->opt->srr) 
                daddr = rt->rt_dst;[/code] 
更新目的地址临时变量——使用路由查找后返回的值。 
 
[code]        if (!inet->saddr) 
                inet->saddr = rt->rt_src; 
        inet->rcv_saddr = inet->saddr;[/code] 
如果还没有设置源地址,和本地发送地址,则使用路由中返回的值。 
 
[code]        if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) { 
                /* Reset inherited state */ 
                tp->rx_opt.ts_recent           = 0; 
                tp->rx_opt.ts_recent_stamp = 0; 
                tp->write_seq                   = 0; 
        } 
 
        if (sysctl_tcp_tw_recycle && 
            !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) { 
                struct inet_peer *peer = rt_get_peer(rt);  
                /* VJ's idea. We save last timestamp seen from 
                 * the destination in peer table, when entering state TIME-WAIT 
                 * and initialize rx_opt.ts_recent from it, when trying new connection. 
                 */ 
 
                if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) { 
                        tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp; 
                        tp->rx_opt.ts_recent = peer->tcp_ts; 
                } 
        }[/code] 
这个更新初始状态方面的内容,还没有去分析它。 
 
[code]        inet->dport = usin->sin_port; 
        inet->daddr = daddr;[/code] 
保存目的地址及端口。 
 
[code]        tp->ext_header_len = 0; 
        if (inet->opt) 
                tp->ext_header_len = inet->opt->optlen;[/code] 
 
[code]tp->rx_opt.mss_clamp = 536;[/code] 
设置最小允许的 mss 值 
[code] 
tcp_set_state(sk, TCP_SYN_SENT);[/code] 
套接字状态被置为 TCP_SYN_SENT, 
 
[code]        err = tcp_v4_hash_connect(sk); 
        if (err) 
                goto failure;[/code] 
动态选择一个本地端口,并加入 hash 表,与bind(2)选择端口类似。 
 
[code]        err = ip_route_newports(&rt, inet->sport, inet->dport, sk); 
        if (err) 
                goto failure; 
 
        /* OK, now commit destination to socket.  */ 
        __sk_dst_set(sk, &rt->u.dst); 
        tcp_v4_setup_caps(sk, &rt->u.dst);[/code] 
因为本地端口已经改变,使用新端口,重新查找路由,并用新的路由缓存项更新 sk 中保存的路由
缓存项。 
 
[code]        if (!tp->write_seq) 
                tp->write_seq = secure_tcp_sequence_number(inet->saddr,                                                            inet->daddr, 
                                                           inet->sport, 
                                                           usin->sin_port);[/code] 
为 TCP报文计算一个 seq值(实际使用的值是 tp->write_seq+1)。 
 
inet->id = tp->write_seq ^ jiffies; 
 
[code]        err = tcp_connect(sk); 
        rt = NULL; 
        if (err) 
                goto failure; 
 
        return 0;[/code] 
tp_connect()函数用来根据 sk 中的信息,构建一个完成的 syn 报文,并将它发送出去。在分析 tcp栈
的实现时再来分析它。 
 
根据 TCP协议,接下来的问题是, 
1、可能收到了服务器的应答,则要回送一个 ack 报文; 
2、如果超时还没有应答,则使用超时重发定时器; 
 
Linux TCP/IP 协议栈之 Socket的实现分析(六  数据包的接收) 
 
前面了解过 sk 有一个接收队列,用于存储接  收到的 skb,对于 socket 层面上来讲,数据接收,就
是要把数据从这个队列中取出来,交给上层用户态。这里涉及到出队操作,但是,要了解如何出队,
就  得了解传输层协议如何入队。前面一直用 tcp协议来分析,现在还没有把整个 tcp栈分析出来,
要再继续用 tcp 协议来分析,就有点问题了,所以,数据的接  收和发送,都将以 udp 协议来分析。
虽然它很简单,但同样也反应了 socket 层数据与接收的全部核心内容与思路。我以希望,下一步拿
下 tcp 协议后,再  把这部份的 tcp 实现补上来。 
 
[color=Red][size=5]一、udp 层的数据接收[/size][/color] 
udp 层的数据接收,对于 socket 而言,就是接收队列的入队操作。在 ip 层中,如果是本地数据,则
会交由 ip_local_deliver_finish()函数处理,它会根据传输层协议的类型,交由相应的处理函数,对于
udp 协议而言,就是 udp_rcv(): 
 
[code] 
/* 
*        All we need to do is get the socket, and then do a checksum.  
*/ 
 
int udp_rcv(struct sk_buff *skb) 

          struct sock *sk; 
          struct udphdr *uh; 
        unsigned short ulen;         struct rtable *rt = (struct rtable*)skb->dst; 
        u32 saddr = skb->nh.iph->saddr; 
        u32 daddr = skb->nh.iph->daddr; 
        int len = skb->len; 
 
        /* 
         *         数据包至少应有 UDP 首部长度. 
         */ 
        if (!pskb_may_pull(skb, sizeof(struct udphdr))) 
                goto no_header; 
                 
        /*获取 udp 首部指针*/ 
        uh = skb->h.uh; 
         
        /*  数据长度,含首部长度 */ 
        ulen = ntohs(uh->len); 
         
        /*  数据包长度不够:UDP 长度比 skb 长度小,意味着数据的丢失,而 udp 长度比 udp 首部
还要小,好像这个不太可能,除非封包出错 ^o^*/ 
        if (ulen > len || ulen < sizeof(*uh)) 
                goto short_packet; 
                 
        /*  截去 udp 报文后面的多余报文 */ 
        if (pskb_trim(skb, ulen)) 
                goto short_packet; 
         
        /*  开始 udp 校验和计算,主要查依赖于 skb 的 ip_summumed 字段的设置来决定是否需要进
行校验和计算 */ 
        if (udp_checksum_init(skb, uh, ulen, saddr, daddr) < 0) 
                goto csum_error; 
         
        /*  转换多播或广播处理例程 */ 
        if(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST)) 
                return udp_v4_mcast_deliver(skb, uh, saddr, daddr); 
         
        /*  查找数据段对应的 socket结构的 sk */ 
        sk = udp_v4_lookup(saddr, uh->source, daddr, uh->dest, skb->dev->ifindex); 
 
        if (sk != NULL) { 
                /*  找到了,数据包进入 UDP 的 socket 的接收队列*/ 
                int ret = udp_queue_rcv_skb(sk, skb); 
                sock_put(sk); 
 
                /* a return value > 0 means to resubmit the input, but                  * it it wants the return to be -protocol, or 0 
                 */ 
                if (ret > 0) 
                        return -ret; 
                return 0; 
        } 
 
        if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) 
                goto drop; 
 
        /*  没有对应的 socket.  如果校验和错误,则丢弃它 */ 
        if (udp_checksum_complete(skb)) 
                goto csum_error; 
         
        /*  发送一个目的不可达报文 */ 
        UDP_INC_STATS_BH(UDP_MIB_NOPORTS); 
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); 
 
        /* 
         * Hmm.  We got an UDP packet to a port to which we 
         * don't wanna listen.  Ignore it. 
         */ 
        kfree_skb(skb); 
        return(0); 
 
short_packet: 
        NETDEBUG(if (net_ratelimit()) 
                printk(KERN_DEBUG "UDP: short packet: From %u.%u.%u.%u:%u %d/%d to 
%u.%u.%u.%u:%u/n", 
                        NIPQUAD(saddr), 
                        ntohs(uh->source), 
                        ulen, 
                        len, 
                        NIPQUAD(daddr), 
                        ntohs(uh->dest))); 
no_header: 
        UDP_INC_STATS_BH(UDP_MIB_INERRORS); 
        kfree_skb(skb); 
        return(0); 
 
csum_error: 
        /*  
         * RFC1122: OK.  Discards the bad packet silently (as far as  
         * the network is concerned, anyway) as per 4.1.3.4 (MUST).           */ 
        NETDEBUG(if (net_ratelimit()) 
                 printk(KERN_DEBUG "UDP: bad checksum. From %d.%d.%d.%d:%d to 
%d.%d.%d.%d:%d ulen %d/n", 
                        NIPQUAD(saddr), 
                        ntohs(uh->source), 
                        NIPQUAD(daddr), 
                        ntohs(uh->dest), 
                        ulen)); 
drop: 
        UDP_INC_STATS_BH(UDP_MIB_INERRORS); 
        kfree_skb(skb); 
        return(0); 
}[/code] 
 
函数的核心思想,是根据 skb,查找到与之对应的 sk,调用 udp_v4_lookup()函数实现——udp 与 tcp
一样,socket有一个 hash表,这个查找,就是查找 hash 表的过程。 
 
如果找到了对应的 sk,则进入 udp_queue_rcv_skb()函数: 
 
[code]/* returns: 
*  -1: error 
*   0: success 
*  >0: "udp encap" protocol resubmission 

* Note that in the success and error cases, the skb is assumed to 
* have either been requeued or freed. 
*/ 
static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb) 

        /*  获取 sk 对应的udp_sock 结构指针 */ 
        struct udp_sock *up = udp_sk(sk); 
 
        /* 
         *        Charge it to the socket, dropping if the queue is full. 
         */ 
        if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) { 
                kfree_skb(skb); 
                return -1; 
        } 
 
        if (up->encap_type) { 
                /* 
                 * This is an encapsulation socket, so let's see if this is                  * an encapsulated packet. 
                 * If it's a keepalive packet, then just eat it. 
                 * If it's an encapsulateed packet, then pass it to the 
                 * IPsec xfrm input and return the response 
                 * appropriately.  Otherwise, just fall through and 
                 * pass this up the UDP socket. 
                 */ 
                int ret; 
 
                ret = udp_encap_rcv(sk, skb); 
                if (ret == 0) { 
                        /* Eat the packet .. */ 
                        kfree_skb(skb); 
                        return 0; 
                } 
                if (ret < 0) { 
                        /* process the ESP packet */ 
                        ret = xfrm4_rcv_encap(skb, up->encap_type); 
                        UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS); 
                        return -ret; 
                } 
                /* FALLTHROUGH -- it's a UDP Packet */ 
        } 
        /*  如果需要校验 */ 
        if (sk->sk_filter && skb->ip_summed != CHECKSUM_UNNECESSARY) { 
                /*  那就校验它吧 */ 
                if (__udp_checksum_complete(skb)) { 
                        /*  结果校验出错,那就算了吧 */ 
                        UDP_INC_STATS_BH(UDP_MIB_INERRORS); 
                        kfree_skb(skb); 
                        return -1; 
                } 
                /*  已经校验过了,就设置不用再校验了 */ 
                skb->ip_summed = CHECKSUM_UNNECESSARY; 
        } 
 
        /*  设用 sock_queue_rcv_skb 入队 */ 
        if (sock_queue_rcv_skb(sk,skb)<0) { 
                UDP_INC_STATS_BH(UDP_MIB_INERRORS); 
                kfree_skb(skb); 
                return -1; 
        } 
        UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS); 
        return 0; }[/code] 
encap_type字段用于判断 udp 包,是否是一个 IPSEC 协议的封装报文,这里不关分 ipsec,所以接下
来的工作,就是校验和计算,然后紧跟着调用 sock_queue_rcv_skb(): 
 
[code]static inline int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) 

        int err = 0; 
        int skb_len; 
 
        /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces 
           number of warnings when compiling with -W --ANK 
         */ 
        if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= 
            (unsigned)sk->sk_rcvbuf) { 
                err = -ENOMEM; 
                goto out; 
        } 
 
        /*  进入 socket 层的包过滤        */ 
        err = sk_filter(sk, skb, 1); 
        if (err) 
                goto out; 
         
        /*  设置 skb 的一些必要的指针和计数器变量 
        dev:关连备设指针; 
        sk:所对应的 sk 结构; 
        destructor:函数指针可以初始化成一个在缓冲区释放时完成某些动作的函数。 
         如果 skb 不属于一个 socket,则其常为 NULL。反之,这个函数会被赋值为 sock_rfree 或
sock_wfree. 
         用于更新 socket的队列中的内存容量。*/ 
        skb->dev = NULL; 
        skb_set_owner_r(skb, sk); 
 
        /* 在skb 入队之前,保存其长度至临时变量 skb_len,这是因为一旦 skb 入队后,它将被 
         其它线程处理,skb 命运未知。。。。。。,而 len 值后面还会用到。 
         */ 
        skb_len = skb->len; 
         
        /* 将skb 加入 sk的接收队列 */ 
        skb_queue_tail(&sk->sk_receive_queue, skb); 
         
        /*  唤醒 socket 上的接收线程? */ 
        if (!sock_flag(sk, SOCK_DEAD)) 
                sk->sk_data_ready(sk, skb_len); out: 
        return err; 
}[/code] 
对于 udp 而言,直接调用 skb_queue_tail(),将 skb 加入至 sk的 sk_receive_queue 队列即可。 
 
[color=Red][size=5]一、udp 层的数据出队操作[/size][/color] 
 
了解了数据包如何被加入队列,上层 socket 的数据接收,就是从这个队列中来取数据。udp 对应的
取数据的函数 udp_recvmsg(),后面再来看它是如何被调用的,现在先来分析它的实现: 
 
[code] 
/* 
*         This should be easy, if there is something there we 
*         return it, otherwise we block. 
*/ 
 
static int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 
                       size_t len, int noblock, int flags, int *addr_len) 

        struct inet_sock *inet = inet_sk(sk);                /*  取得 sk对应的 inet_sock 指针 */ 
          struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name; 
          struct sk_buff *skb; 
          int copied, err; 
 
        /* 
         *         校验地址长度 
         */ 
        if (addr_len) 
                *addr_len=sizeof(*sin); 
        /*  如果 sk 队列中有错误的信息,则设用 ip_recv_error函数 */ 
        if (flags & MSG_ERRQUEUE) 
                return ip_recv_error(sk, msg, len); 
 
try_again: 
        /*  出队 */ 
        skb = skb_recv_datagram(sk, flags, noblock, &err); 
        if (!skb) 
                goto out; 
          /*  需要拷贝的数据不包含 UDP 首部 */ 
          copied = skb->len - sizeof(struct udphdr); 
          /*  如果用户提供的缓存不够,则设置为只拷贝用户需要的长度,并设置截短数据标志 */ 
        if (copied > len) { 
                copied = len; 
                msg->msg_flags |= MSG_TRUNC;         } 
         
        if (skb->ip_summed==CHECKSUM_UNNECESSARY) { 
                /*  拷贝数据至用户空间 */ 
                err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov, 
                                              copied); 
        } else if (msg->msg_flags&MSG_TRUNC) { 
                if (__udp_checksum_complete(skb)) 
                        goto csum_copy_err; 
                err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov, 
                                              copied); 
        } else { 
                err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov); 
 
                if (err == -EINVAL) 
                        goto csum_copy_err; 
        } 
 
        if (err) 
                goto out_free; 
        /*  更新 sk 的接收时间戳,根据 SOCK_RCVTSTAMP标志的设置来决定:选择当前时间还是
skb buffer的接收时间 */ 
        sock_recv_timestamp(msg, sk, skb); 
 
        /*  拷贝地址等信息. */ 
        if (sin) 
        { 
                sin->sin_family = AF_INET; 
                sin->sin_port = skb->h.uh->source; 
                sin->sin_addr.s_addr = skb->nh.iph->saddr; 
                memset(sin->sin_zero, 0, sizeof(sin->sin_zero)); 
          } 
          /*  查看是否设置了一些控制标志,查看某些IP socket选项是否被设置,例如,设置了IP_TOS 
socket 选项,把 IP首部中的 
          tos字段拷贝至用户空间等等,这个工作是由 ip_cmsg_recv 函数完成的 */ 
        if (inet->cmsg_flags) 
                ip_cmsg_recv(msg, skb); 
         
        /*  设置拷贝的字节数,如果数据段已经被截短,则返回原始实际的长度 */ 
        err = copied; 
        if (flags & MSG_TRUNC) 
                err = skb->len - sizeof(struct udphdr); 
   
out_free:           skb_free_datagram(sk, skb); 
out: 
          return err; 
 
csum_copy_err: 
        UDP_INC_STATS_BH(UDP_MIB_INERRORS); 
 
        /* Clear queue. */ 
        if (flags&MSG_PEEK) { 
                int clear = 0; 
                spin_lock_bh(&sk->sk_receive_queue.lock); 
                if (skb == skb_peek(&sk->sk_receive_queue)) { 
                        __skb_unlink(skb, &sk->sk_receive_queue); 
                        clear = 1; 
                } 
                spin_unlock_bh(&sk->sk_receive_queue.lock); 
                if (clear) 
                        kfree_skb(skb); 
        } 
 
        skb_free_datagram(sk, skb); 
 
        if (noblock) 
                return -EAGAIN;         
        goto try_again; 
}[/code] 
 
skb 的出队,是通过调用 skb_recv_datagram()函数,出队操作时,队列中可能没有数据,如果是阻
塞,则需要一直睡眠等待,直到超时或队  列中有数据而被唤醒。另外出队操作,还分为两种情况,
一种是将数据包从队列中取中来,将其从原有队列中删除,还有一种可能是设置了 MSG_PEEK 标
志,  它意味着:“查看当前数据,数据将被复制到缓冲区中,但并不从输入队列中删除”。 
 
[code]struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, 
                                  int noblock, int *err) 

        struct sk_buff *skb; 
        long timeo; 
        /* 
         * Caller is allowed not to check sk->sk_err before skb_recv_datagram() 
         */ 
        int error = sock_error(sk); 
 
        if (error) 
                goto no_packet;          
        /*  获取超时时间*/ 
        timeo = sock_rcvtimeo(sk, noblock); 
         
        /*  这个循环将一直等到队列中有数据包,直到超时 */ 
        do { 
                /* Again only user level code calls this function, so nothing 
                 * interrupt level will suddenly eat the receive_queue. 
                 * 
                 * Look at current nfs client by the way... 
                 * However, this function was corrent in any case. 8) 
                 */ 
                if (flags & MSG_PEEK) { 
                        unsigned long cpu_flags; 
                        /*  如果设置了 MSG_PEEK,则设用 skb_peek,这里要对接收队列加锁的原因
在于: 
                        */ 
                        spin_lock_irqsave(&sk->sk_receive_queue.lock, 
                                          cpu_flags); 
                        skb = skb_peek(&sk->sk_receive_queue); 
                        if (skb) 
                                atomic_inc(&skb->users); 
                        spin_unlock_irqrestore(&sk->sk_receive_queue.lock, 
                                               cpu_flags); 
                } else 
                        skb = skb_dequeue(&sk->sk_receive_queue);                /* 直接出队 */ 
                 
                /*  找到要收获的葫芦了,摘下来 */ 
                if (skb) 
                        return skb; 
 
                /*  如果是非阻塞,就不等了,直接跳出循环,返回 */ 
                error = -EAGAIN; 
                if (!timeo) 
                        goto no_packet; 
 
        } while (!wait_for_packet(sk, err, &timeo)); 
 
        return NULL; 
 
no_packet: 
        *err = error; 
        return NULL; 
}[/code]  
继续回到 udp_recvmsg 函数中来,当取出 skb 后,需要将它拷贝至用户空间。用户空间的数据缓存,
用了一个很重要的数据结构 struct msghdr来表示: 
 
[code]struct msghdr { 
        void        *        msg_name;        /* Socket name                        */ 
        int                msg_namelen;        /* Length of name                */ 
        struct iovec *        msg_iov;        /* Data blocks                        */ 
        __kernel_size_t        msg_iovlen;        /* Number of blocks                */ 
        void         *        msg_control;        /* Per protocol magic (eg BSD file descriptor passing) */ 
        __kernel_size_t        msg_controllen;        /* Length of cmsg list */ 
        unsigned        msg_flags; 
};[/code] 
结构中的 msg_name、 msg_namelen 以及 msg_flags分别对应于 sys_sendto()[其它接收/发送函数类似]
的参数 addr、addr_len 以及 flags。指针 msg_control 可以指向一个附加的数据结构,用来提供一些
附加的控制信息。后面可以看到 ip_cmsg_recv()使用了它。最重要的是,结构中的指针 msg_iov,
指向一个 iovec 结构数据,而 msg_iovlen 则指明了这个数组  的大小: 
[code]struct iovec 

        void __user *iov_base;        /* BSD uses caddr_t (1003.1g requires void *) */ 
        __kernel_size_t iov_len; /* Must be size_t (1003.1g) */ 
};[/code] 
 
数组中的每一个元互素,都是 struct iovec 结构, 称之为"io 向量",由指向数据缓冲区的指针 iov_base
和表示缓冲区中数据长度的 iov_len构成。这样,一个 msghdr中的数据,就由控制信息 msg_control
和若干个"io向量"组成。 
 
一个疑问是,为什么不设置为一个缓冲区,而要分为若干个缓冲区呢?一个很重要的原因就是,每
个数据报文的大小一致,对于 ip 包而言。46-1500 都是为  可能的,那么如果是一个缓冲区的话,
就得定义为一个“最大值”,但是如果绝大部份的包,都小于这个最大值,例如为 256 或 512,那么
内存空间就浪费得太  多了……。所以,一个好的办法是,用一个个小的缓冲区将数据切分,要浪
费,也浪费最后一个缓冲区的空间。——这种设计跟 Unix上著名的 mbuf好像是一 致的。 
 
OK,了解了 msghdr 的结构后,再来看数据的拷贝工作,拷贝的核心函数是 memcpy_toiovec: 
[code]/* 
*        Copy kernel to iovec. Returns -EFAULT on error. 

*        Note: this modifies the original iovec. 
*/ 
 
int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len) 

        while (len > 0) { 
                if (iov->iov_len) {                         int copy = min_t(unsigned int, iov->iov_len, len); 
                        if (copy_to_user(iov->iov_base, kdata, copy)) 
                                return -EFAULT; 
 
                        kdata += copy; 
                        len -= copy; 
                        iov->iov_len -= copy; 
                        iov->iov_base += copy; 
                } 
                iov++; 
        } 
 
        return 0; 
}[/code] 
 
因为每个 io向量的缓冲区可能很小,例如 100字节,而要拷贝的数据很长,例如 1000 字节。这样,
需要在一个循环里,将数据拷贝至若干个 
io 向量数组元素当中去。 
 
回到 udp_recvmsg 中来,它通过设用 skb_copy_datagram_iovec()函数完成数据的拷贝工作。来看看
它是如何调用 memcpy_toiovec 的,当然,类似于这样: 
[code]int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset, 
                            struct iovec *to, int len) 

        return memcpy_toiovec(to, skb->data+offset, len); 
}[/code] 
 
这样的调用,该是多么美好呀,这样的日子曾经是有过,不过已经一去不复返了。 
 
考虑到 skb 结构的复杂性,例如分片,拷贝工作要复杂得多: 
[code] 
/** 
*        skb_copy_datagram_iovec - Copy a datagram to an iovec. 
*        @skb: buffer to copy 
*        @offset: offset in the buffer to start copying from 
*        @to: io vector to copy to 
*        @len: amount of data to copy from buffer to iovec 

*        Note: the iovec is modified during the copy. 
*/ 
int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset, 
                            struct iovec *to, int len) 

        int start = skb_headlen(skb);                /* start 表示要从 skb 的哪里开始拷贝数据 */         int i, copy = start - offset;                /* offset  表示调用者指出的缓存开始拷贝的偏移字节,
一般情况下,它 
                                                 与 start 是重叠的,表示不需要拷贝数据包的首部 */ 
 
        /*  需要拷贝首部. */ 
        if (copy > 0) { 
                if (copy > len) 
                        copy = len; 
                if (memcpy_toiovec(to, skb->data + offset, copy)) 
                        goto fault; 
                if ((len -= copy) == 0) 
                        return 0; 
                offset += copy; 
        } 
 
        /*  遍历每一个分片 */ 
        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 
                int end; 
 
                BUG_TRAP(start <= offset + len); 
 
                end = start + skb_shinfo(skb)->frags[i].size; 
                if ((copy = end - offset) > 0) { 
                        int err; 
                        u8  *vaddr; 
                        skb_frag_t *frag = &skb_shinfo(skb)->frags[i]; 
                        struct page *page = frag->page; 
 
                        if (copy > len) 
                                copy = len; 
                        vaddr = kmap(page); 
                        err = memcpy_toiovec(to, vaddr + frag->page_offset + 
                                             offset - start, copy); 
                        kunmap(page); 
                        if (err) 
                                goto fault; 
                        if (!(len -= copy)) 
                                return 0; 
                        offset += copy; 
                } 
                start = end; 
        } 
 
        if (skb_shinfo(skb)->frag_list) {                 struct sk_buff *list = skb_shinfo(skb)->frag_list; 
 
                for (; list; list = list->next) { 
                        int end; 
 
                        BUG_TRAP(start <= offset + len); 
 
                        end = start + list->len; 
                        if ((copy = end - offset) > 0) { 
                                if (copy > len) 
                                        copy = len; 
                                if (skb_copy_datagram_iovec(list, 
                                                            offset - start, 
                                                            to, copy)) 
                                        goto fault; 
                                if ((len -= copy) == 0) 
                                        return 0; 
                                offset += copy; 
                        } 
                        start = end; 
                } 
        } 
        if (!len) 
                return 0; 
 
fault: 
        return -EFAULT; 
}[/code] 
 
现在还没有分析 ip 的分片,所以,要完全理解这个函数的代码有点难度,等到 ip 分片分析完了,
再来补充完整它。 
 
[code]三、socket 层的数据接收[/code] 
recv(2)、recvfrom(2)和 recvmsg(3),在 sys_socketcall()中,最终都会归于一个统一的系统调用
sock_recvmsg。例如: 
[code]asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags) 

        return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 
}[/code] 
sys_recv 转向了 sys_recvfrom(): 
[code] 
/* 
*        Receive a frame from the socket and optionally record the address of the  
*        sender. We verify the buffers are writable and if needed move the *        sender address from kernel to user space. 
*/ 
 
asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags, 
                             struct sockaddr __user *addr, int __user *addr_len) 

        struct socket *sock; 
        struct iovec iov; 
        struct msghdr msg; 
        char address[MAX_SOCK_ADDR]; 
        int err,err2; 
 
        sock = sockfd_lookup(fd, &err); 
        if (!sock) 
                goto out; 
 
        msg.msg_control=NULL; 
        msg.msg_controllen=0; 
        msg.msg_iovlen=1; 
        msg.msg_iov=&iov; 
        iov.iov_len=size; 
        iov.iov_base=ubuf; 
        msg.msg_name=address; 
        msg.msg_namelen=MAX_SOCK_ADDR; 
        if (sock->file->f_flags & O_NONBLOCK) 
                flags |= MSG_DONTWAIT; 
        err=sock_recvmsg(sock, &msg, size, flags); 
 
        if(err >= 0 && addr != NULL) 
        { 
                err2=move_addr_to_user(address, msg.msg_namelen, addr, addr_len); 
                if(err2<0) 
                        err=err2; 
        } 
        sockfd_put(sock);                         
out: 
        return err; 
}[/code] 
 
函数先调用 sockfd_lookup,根据 socket 描述符查找以相应的 sock 结构,然后封装了一个 msghdr结
构后,接着调用 sock_recvmsg()。 
[code]int sock_recvmsg(struct socket *sock, struct msghdr *msg,  
                 size_t size, int flags) 
{         struct kiocb iocb; 
        struct sock_iocb siocb; 
        int ret; 
 
        init_sync_kiocb(&iocb, NULL); 
        iocb.private = &siocb; 
        ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 
        if (-EIOCBQUEUED == ret) 
                ret = wait_on_sync_kiocb(&iocb); 
        return ret; 
}[/code] 
 
iocb 和 siocb 用于内核和 socket 的 io 控制,函数中主要初始化了 iocb,siocb 的初始化,在
__sock_recvmsg 中完成。 
进一步的按收动作,是通过__sock_recvmsg 函数设用完成的: 
[code]static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,  
                                 struct msghdr *msg, size_t size, int flags) 

        int err; 
        struct sock_iocb *si = kiocb_to_siocb(iocb); 
 
        si->sock = sock; 
        si->scm = NULL; 
        si->msg = msg; 
        si->size = size; 
        si->flags = flags; 
 
        err = security_socket_recvmsg(sock, msg, size, flags); 
        if (err) 
                return err; 
 
        return sock->ops->recvmsg(iocb, sock, msg, size, flags); 

[/code] 
初始化完 siocb,也就是 si 后,调用协议簇的 recvmsg 函数,对于 UDP 而言,是
sock_common_recvmsg(): 
[code]int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock, 
                        struct msghdr *msg, size_t size, int flags) 

        struct sock *sk = sock->sk;    /*取得 sock 结构对应的 sk指针*/ 
        int addr_len = 0; 
        int err; 
 
        err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,                                    flags & ~MSG_DONTWAIT, &addr_len); 
        if (err >= 0) 
                msg->msg_namelen = addr_len; 
        return err; 
}[/code] 
 
于是,udp_recvmsg 就被调用了。整个过程也就结束了。 
 
最后再回到 sys_recvfrom中来,如果用户调用时,需要返回对方的地址信息: 
[code]        if(err >= 0 && addr != NULL) 
        { 
                err2=move_addr_to_user(address, msg.msg_namelen, addr, addr_len); 
                if(err2<0) 
                        err=err2; 
        }[/code] 
 
就需要调用 move_addr_to_user()  函数来完成,前面分析 msghdr 结构时已经提到其 msg_name 成员
变量,它包含了地址的相应信息,msg.msg_namelen 成员变量,决定了地址的长度信息: 
[code]int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen) 

        int err; 
        int len; 
 
        if((err=get_user(len, ulen)))     //缓存长度校验 
                return err; 
        if(len>klen) 
                len=klen; 
        if(len<0 || len> MAX_SOCK_ADDR) 
                return -EINVAL; 
        if(len) 
        { 
                if(copy_to_user(uaddr,kaddr,len))   //拷贝地址信息 
                        return -EFAULT; 
        } 
        /* 
         *        "fromlen shall refer to the value before truncation.." 
         *                        1003.1g 
         */ 
        return __put_user(klen, ulen);  
}[/code]