tcp/ip协议栈--socket API 之accept()

0x01 缘由

     前面博文已经学习了socket()\bind()，一切准备好后，开始可以接受客户端的连接请求，建立连接了。下面学习下accept API相关细节。

0x02 API介绍

在建立好接收队列以后，服务器就调用accept()，然后睡眠直到有客户端的连接请求到达。默认为阻塞API。

0x03 源码单步跟踪

     环境：linux kernel 2.6.32

     guest： 运行server host：设置断点

3.1 SYSCALL_DEFINE2

  /*
 *    系统调用向量
 */
SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
{
    unsigned long a[6];
    unsigned long a0, a1;
    int err;
    unsigned int len;

    if (call < 1 || call > SYS_ACCEPT4)
        return -EINVAL;

    len = nargs[call];
    if (len > sizeof(a))
        return -EINVAL;

    /* 用户空间复制相关参数 */
    if (copy_from_user(a, args, len))
        return -EFAULT;

    audit_socketcall(nargs[call] / sizeof(unsigned long), a);

    a0 = a[0];
    a1 = a[1];
    /* 根据call子调用号，来处理socket相关调用状态。*/
    switch (call) {
     ......
        case SYS_ACCEPT:
            /* a0 文件描述符  后面两个参数分别对应api描述中的地址和地址长度 */
            err = sys_accept4(a0, (struct sockaddr __user *)a1,
                      (int __user *)a[2], 0);
            break;
    .......
    default:
        err = -EINVAL;
        break;
    }
    return err;
}

3.2 SYSCALL_DEFINE4

/*  尝试创建一个socket结构，与客户端请求连接，唤醒客户端，然后返回一个新的fd。我们在linux内核空间手机链接的地址，复制到用户空间。*/
SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
        int __user *, upeer_addrlen, int, flags)
{
    struct socket *sock, *newsock;  //新socket结构指针
    struct file *newfile;    //新文件描述符
    int err, len, newfd, fput_needed;
    struct sockaddr_storage address;
    /* 只允许使用这两个标志 */ 
    if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
        return -EINVAL;

    if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
        flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
    /* 通过文件描述符查找对应的结构 */
    sock = sockfd_lookup_light(fd, &err, &fput_needed);
    if (!sock)
        goto out;

    err = -ENFILE;
    /*申请newsock结构指向newsock */
    if (!(newsock = sock_alloc()))
        goto out_put;
    /* 拷贝相关信息 */
    newsock->type = sock->type;
    newsock->ops = sock->ops;

    /* 这里我们不需要try_module_get，应为在listen环节已处理。
     */
    __module_get(newsock->ops->owner);
    /* 申请新的文件描述符 */
    newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
    if (unlikely(newfd < 0)) {
        err = newfd;
        sock_release(newsock);
        goto out_put;
    }
    /* 将新的文件描述符和socke进行关联。*/
    err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
    if (err < 0)
        goto out_fd_simple;
    /* SELinux相关 */ 
    err = security_socket_accept(sock, newsock);
    if (err)
        goto out_fd;

    /* SOCKET层的操作函数，如果是SOCK_STREAM，proto_ops为inet_stream_ops，
   * 接下来调用inet_accept()。
   */ 
    err = sock->ops->accept(sock, newsock, sock->file->f_flags);
    if (err < 0)
        goto out_fd;
    /* 如果要保存对端地址 */
    if (upeer_sockaddr) {
        /* 获取对端的地址，以及地址的长度 */
        if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
                      &len, 2) < 0) {
            err = -ECONNABORTED;
            goto out_fd;
        }
        /* 把内核空间的socket地址复制到用户空间 */
        err = move_addr_to_user((struct sockaddr *)&address,
                    len, upeer_sockaddr, upeer_addrlen);
        if (err < 0)
            goto out_fd;
    }

    /*以newfd为索引，把newfile加入当前进程的文件描述符表files_struct中。*/
    fd_install(newfd, newfile);
    err = newfd;

out_put:
    fput_light(sock->file, fput_needed);
out:
    return err;
out_fd_simple:
    sock_release(newsock);
    put_filp(newfile);
    put_unused_fd(newfd);
    goto out_put;
out_fd:
    fput(newfile);
    put_unused_fd(newfd);
    goto out_put;
}
sys_accept4()主要做了：
1创建了一个新的socket和inode，以及它所对应的fd、file。
2调用Socket层操作函数inet_accept()。
3保存对端地址到指定的用户空间地址。

3.3 inet_accept  

/*inet_accept()主要做了：
1.调用TCP层的操作函数，获取已建立的连接sock。
2.把新socket和sock关联起来。
3.把新socket的状态设为SS_CONNECTED。*/
int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
    struct sock *sk1 = sock->sk;
    int err = -EINVAL;
    /* 如果使用的是TCP，则sk_prot为tcp_prot，accept为inet_csk_accept()
   * 获取新连接的sock。
   */ 
    struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);

    if (!sk2)
        goto do_err;

    lock_sock(sk2);

    WARN_ON(!((1 << sk2->sk_state) &
          (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE)));

 /* 把sock和socket嫁接起来，让它们能相互索引 */ 
    sock_graft(sk2, newsock);

    /* 把新socket的状态设为已连接 */ 
    newsock->state = SS_CONNECTED;
    err = 0;
    release_sock(sk2);
do_err:
    return err;
}

3.4 inet_csk_accept

 * 将接受下一个未完成的连接。
 * inet_csk_accept()用于从backlog队列（全连接队列）中取出一个ESTABLISHED状态的连接请求块，返回它所对应的连接sock。
 *    1.非阻塞的，且当前没有已建立的连接，则直接退出，返回-EAGAIN。
 *  2.阻塞的，且当前没有已建立的连接：
 *   2.1 用户没有设置超时时间，则无限期阻塞。
 *   2.2 用户设置了超时时间，超时后会退出。
 */
struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
{
    struct inet_connection_sock *icsk = inet_csk(sk); //连接
    struct sock *newsk;
    int error;

    lock_sock(sk);

    /* 必须保证socket处于监听状态。
     */
    error = -EINVAL;
    if (sk->sk_state != TCP_LISTEN)
        goto out_err;

    /*找已经建立的连接，也就是客户端和服务端完成了三次握手后，将连接放入队列。*/
    if (reqsk_queue_empty(&icsk->icsk_accept_queue)) {
        /* 没有新的连接 ，获取超时时间*/
        long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

        /* 如果是非阻塞socket则直接返回，不用等待 */
        error = -EAGAIN;
        if (!timeo)
            goto out_err;
        /* 阻塞等待，直到有全连接。如果用户有设置等待超时时间，超时后会退出 */ 
        error = inet_csk_wait_for_connect(sk, timeo);
        if (error)
            goto out_err;
    }
/* 获取新连接的sock，释放连接控制块 */ 
    newsk = reqsk_queue_get_child(&icsk->icsk_accept_queue, sk);
    WARN_ON(newsk->sk_state == TCP_SYN_RECV);
out:
    release_sock(sk);
    return newsk;
out_err:
    newsk = NULL;
    *err = error;
    goto out;
}

3.5 inet_csk_wait_for_connect

/*等待一个进来的连接，为了避免竞争产生，此处必须对socket加锁。*/
static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    DEFINE_WAIT(wait);  /* 初始化等待任务 */ 
    int err;

    /*
    真正的唤醒-传入连接的机制：只有一个进程被唤醒，而不是“所有进程”。由于我们不再
    对已建立的套接字进行“竞争和轮询”，所以通常情况下只执行一次循环。 微妙问题：在
    任何当前的非排他性服务器之后，将添加“add_wait_queue_exclusive（）”，并且我们知
    道在任何新的非排他性服务器之后它总是_stay_，因为在等待队列的开头添加了所有非独占
    服务器。 因此，当我们被唤醒而不必删除并重新插入到等待队列中时，可以暂时“放弃”我
    们的排他性。
     */
    for (;;) {
        /* 把等待任务加入到socket的等待队列中，把进程状态设置为TASK_INTERRUPTIBLE */
        prepare_to_wait_exclusive(sk->sk_sleep, &wait,
                      TASK_INTERRUPTIBLE);
        /* 等下可能要阻塞休眠，先释放 */ 
        release_sock(sk);
        /* 如果全连接队列为空 */
        if (reqsk_queue_empty(&icsk->icsk_accept_queue))
            /* 进入睡眠，直到超时或收到信号 */
            timeo = schedule_timeout(timeo);
        /* 超时唤醒后重新上锁 */ 
        lock_sock(sk);
        err = 0;
        /* 全连接队列不为空时，退出 */
        if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
            break;
        err = -EINVAL;
        /* 如果sock不处于监听状态了，退出 */
        if (sk->sk_state != TCP_LISTEN)
            break;
        /* 如果进程有待处理的信号，退出。
     * 因为timeo默认为MAX_SCHEDULE_TIMEOUT，所以err默认为-ERESTARTSYS。
     * 接下来会重新调用此函数，所以accept()依然阻塞。
     */ 
        err = sock_intr_errno(timeo);
        if (signal_pending(current))
            break;
        err = -EAGAIN;
        if (!timeo)
            break;
    }
    /*完成相关等待操作*/
    finish_wait(sk->sk_sleep, &wait);
    return err;
}

3.6 accept()的唤醒

当收到客户端的ACK后，经过如下调用：

--tcp_v4_rcv
     --tcp_v4_do_rcv
          --tcp_child_process
               --sock_def_readable
                    --wake_up_interruptible_sync_poll
                         --__wake_up_sync_key
                              --__wake_up_common

最终调用我们给等待任务注册的唤醒函数。

3.7 唤醒后处理建立连接了

void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
    unsigned long flags;

    __set_current_state(TASK_RUNNING);

    if (!list_empty_careful(&wait->task_list)) {
        spin_lock_irqsave(&q->lock, flags);
        list_del_init(&wait->task_list);  /* 从等待队列中删除，初始化此等待任务 */
        spin_unlock_irqrestore(&q->lock, flags);
    }
}

0x04 总结

        经过以上服务端接收一个连接的操作过程已经完成了，没有直接参数tcp层相关操作，通过队列来做为消息来判断。下面分析客户端connect过程。