开发者社区> xumaojun> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Linux TCP/IP协议栈之Socket的实现分析(socket listen)

简介: sys_listen对面向连接的协议,在调用 bind(2)后,进一步调用 listen(2),让套接字进入监听状态: int listen(int sockfd, int backlog);backlog 表示新建连接请求时,最大的未处理的积压请求数。
+关注继续查看
sys_listen

对面向连接的协议,在调用 bind(2)后,进一步调用 listen(2),让套接字进入监听状态:
int listen(int sockfd, int backlog);

backlog 表示新建连接请求时,最大的未处理的积压请求数。
 
这里说到让套接字进入某种状态,也就是说,涉及到套接字的状态变迁,前面 create 和bind 时,也遇到过相应的代码。
 
sock和 sk 都有相应的状态字段,先来看 sock 的:
typedef enum {
        SS_FREE = 0,                        /*  套接字未分配  */
        SS_UNCONNECTED,              /*  套接字未连接  */
        SS_CONNECTING,                  /*  套接字正在处理连接 */
        SS_CONNECTED,                   /*  套接字已连接 */
        SS_DISCONNECTING              /*  套接字正在处理关闭连接 */
}socket_state;
 
在创建套接字时,被初始化为SS_UNCONNECTED
 
对于面向连接模式的SOCK_TREAM来讲,这样描述状态显然是不够的。这样在sk中, 使用sk_state维护了一个有限状态机
来描述套接字的状态:
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! */
};
 
还有一个相应的用来进行状态位运算的枚举结构:
enum {
  TCPF_ESTABLISHED = (1   TCPF_SYN_SENT = (1   TCPF_SYN_RECV = (1   TCPF_FIN_WAIT1 = (1   TCPF_FIN_WAIT2 = (1   TCPF_TIME_WAIT = (1   TCPF_CLOSE = (1   TCPF_CLOSE_WAIT = (1   TCPF_LAST_ACK = (1   TCPF_LISTEN = (1   TCPF_CLOSING = (1 };
 
值得一提的是,sk 的状态不等于 TCP的状态,虽然 sk 是面向协议栈,但它的状态并不能同 TCP状态一一直接划等号。
虽然这些状态值都用 TCP-XXX 来表式,但是只是因为 TCP协议状态非常复杂。sk 结构只是利用它的一个子集来抽像
描述而已。
 
同样地,操作码 SYS_LISTEN的任务会落到 sys_listen()函数身上:
/* 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;
}
 
同样地,函数会最终转向协议簇的 listen 函数,也就是 inet_listen():
 
/*
*        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                 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;
}
 
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 报文了,那么在此
之前,需要先初始化这个表: 
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 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;
}
 
在切换了有限状态机状态后,调用了
sk->sk_prot->hash(sk);
也就是 tcp_v4_hash()函数。这里涉到到另一个 hash 表:TCP监听 hash 表。
 
TCP监听 hash表
所谓 TCP 监听表,指的就内核维护“当前有哪些套接字在监听”的一个表,当一个数据包进入 TCP
栈的时候,内核查询这个表中对应的 sk,以找到相应的数据 结构。(因为 sk 是面向网络栈调用的,找到了sk,
就找到了 tcp_sock,就找到了 inet_sock,就找到了 sock,就找到了 fd……就到了组  织了)。
 
TCP所有的 hash 表都用了tcp_hashinfo来封装,前面分析 bind已见过它:
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)
 
函数 tcp_v4_hash 将一个处理监听状态下的 sk 加入至这个 hash 表:
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();
        }
}
 
因为__tcp_v4_hash 不只用于监听 hash 表,它也用于其它 hash 表,其第二个参数 listen_possible 为
真的时候,表示处理的是监听 hash表:
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);
}
else 中的部份用于另一个 hash 表,暂时不管它。代表很简单,如果确认是处理的是监听 hash 表。
则先根据 sk计算一个 hash 值,在hash 桶中找到入口。再调用__sk_add_node 加入至该 hash 链。
 
tcp_sk_listen_hashfn()函数事实上是 tcp_lhashfn 的包裹,前面已经分析过了。
 
__sk_add_node()函数也就是一个简单的内核 hash处理函数 hlist_add_head()的包裹:
static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
{
        hlist_add_head(&sk->sk_node, list);
}
 
小结
 
一个套接字的 listen,主要需要做的工作有以下几件:
1. 初始化 sk 相关的成员变量,最重要的是 listen_opt,也就是连接请求 hash 表。
2. 将 sk 的有限状态机转换为 TCP_LISTEN,即监听状态;
3. 将 sk 加入监听 hash表;
4. 设置允许的最大请求积压数,也就是 sk 的成员 sk_max_ack_backlog 的值。 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
浅入分析Linux
Linux 操作系统必须完成的两个主要目的 与硬件部分交互, 为包含在硬件平台上的所有底层可编程部件提供服务 为运行在计算机系统上的应用程序(即所谓的用户空间)提供执行环境 一些操作系统运行所有的用户程序都直接与硬件部分进行交互, 比如典型的MS-DOS。
843 0
Linux系统常用的命令
买下云服务器如何操作(Linux系统)
16 0
五种绕过 Linux 命令别名的方法
我们可以使用 alias 命令定义或显示 bash shell 别名。一旦创建了 Bash shell 别名,它们将优先于外部或内部命令。本文将展示如何暂时绕过 bash 别名,以便你可以运行实际的内部或外部命令。
1087 0
Linux vmstat命令实战详解
vmstat命令是最常见的Linux/Unix监控工具,可以展现给定时间间隔的服务器的状态值,包括服务器的CPU使用率,内存使用,虚拟内存交换情况,IO读写情况。这个命令是我查看Linux/Unix最喜爱的命令,一个是Linux/Unix都支持,二是相比top,我可以看到整个机器的CPU,内存,IO的使用情况,而不是单单看到各个进程的CPU使用率和内存使用率(使用场景不一样)。
857 0
Linux命令复习和练习
============================================================================= Linux命令复习和练习: ---------------------------------------------------------...
1331 0
Linux命令复习和练习_02
tar是Unix/Linux中最常用的备份工具,该命令可以把一系列文档归档到一个大文件中,也可以把档案文件解开以恢复数据。 tar -cvf test.tar a.c b.txt c.py 把a.
1316 0
Linux命令复习和练习_03
apt终端命令 deb安装格式   安装搜狗输入法的操作如下如所示:    我的GitHub地址:https://github.com/heizemingjun 我的博客园地址:http://www.
836 0
Linux命令复习和练习_01
Linux命令复习和练习: linux命令格式:  command [-options] [parameter1] [parameter2] ...  命令    选项    参数 例如:  ls /      命令+参数  ls -a    命令+选项 注意:   1.若有多个选项,选项没有先后顺序,且选项可以合并。
1832 0
【Python Learning第一篇】Linux命令学习及Vim命令的使用
学了两天,终于把基本命令学完了,掌握以后可以当半个程序员了(^∇^*) 此文是一篇备忘录或者查询笔记,如果哪位大佬看上了并且非常嫌弃的话,还请大佬不吝赐教,多多包涵 以下是我上课做的一些笔记,非常的凌乱,(⊙﹏⊙)反正是留给自己看的 Day1学习: 以Ubuntu为例子Ctrl + Shi...
1076 0
+关注
xumaojun
乐于学习与分析
1078
文章
95
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载