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过程。