TCP层accept系统调用的实现分析

inet_csk_accept函数实现了tcp协议accept操作，其主要完成的功能是，从已经完成三次握手的队列中取控制块，如果没有已经完成的连接，则需要根据阻塞标记来来区分对待，若非阻塞则直接返回，若阻塞则需要在一定时间范围内阻塞等待；

 /*
  * This will accept the next outstanding connection.
  */
 struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
 {
     struct inet_connection_sock *icsk = inet_csk(sk);
     struct request_sock_queue *queue = &icsk->icsk_accept_queue;
     struct request_sock *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;

     /* 不是listen状态 */
     if (sk->sk_state != TCP_LISTEN)
         goto out_err;

     /* Find already established connection */

     /* 还没有已完成的连接 */
     if (reqsk_queue_empty(queue)) {

         /* 获取等待时间，非阻塞为0 */
         long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);

         /* If this is a non blocking socket don't sleep */
         error = -EAGAIN;
         /* 非阻塞立即返回错误 */
         if (!timeo)
             goto out_err;

         /* 等待连接到来 */
         error = inet_csk_wait_for_connect(sk, timeo);
         if (error)
             goto out_err;
     }

     /* 从已完成连接队列中移除 */
     req = reqsk_queue_remove(queue, sk);

     /* 设置新控制块指针 */
     newsk = req->sk;

     /* TCP协议 && fastopen */
     if (sk->sk_protocol == IPPROTO_TCP &&
         tcp_rsk(req)->tfo_listener) {
         spin_lock_bh(&queue->fastopenq.lock);
         if (tcp_rsk(req)->tfo_listener) {
             /* We are still waiting for the final ACK from 3WHS
              * so can't free req now. Instead, we set req->sk to
              * NULL to signify that the child socket is taken
              * so reqsk_fastopen_remove() will free the req
              * when 3WHS finishes (or is aborted).
              */
             req->sk = NULL;
             req = NULL;
         }
         spin_unlock_bh(&queue->fastopenq.lock);
     }
 out:
     release_sock(sk);

     /* 释放请求控制块 */
     if (req)
         reqsk_put(req);

     /* 返回找到的连接控制块 */
     return newsk;
 out_err:
     newsk = NULL;
     req = NULL;
     *err = error;
     goto out;
 }

如果请求队列中没有已完成握手的连接，并且套接字已经设置了阻塞标记，则需要加入调度队列等待连接的到来，inet_csk_wait_for_connect函数完成了这个功能；

 /*
  * Wait for an incoming connection, avoid race conditions. This must be called
  * with the socket locked.
  */
 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;

     /*
      * True wake-one mechanism for incoming connections: only
      * one process gets woken up, not the 'whole herd'.
      * Since we do not 'race & poll' for established sockets
      * anymore, the common case will execute the loop only once.
      *
      * Subtle issue: "add_wait_queue_exclusive()" will be added
      * after any current non-exclusive waiters, and we know that
      * it will always _stay_ after any new non-exclusive waiters
      * because all non-exclusive waiters are added at the
      * beginning of the wait-queue. As such, it's ok to "drop"
      * our exclusiveness temporarily when we get woken up without
      * having to remove and re-insert us on the wait queue.
      */
     for (;;) {

         /* 加入等待队列 */
         prepare_to_wait_exclusive(sk_sleep(sk), &wait,
                       TASK_INTERRUPTIBLE);
         release_sock(sk);

         /* 如果为空计算，进行调度 */
         if (reqsk_queue_empty(&icsk->icsk_accept_queue))
             timeo = schedule_timeout(timeo);
         sched_annotate_sleep();
         lock_sock(sk);
         err = ;
         /* 队列不为空*/
         if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
             break;
         err = -EINVAL;
         /* 连接状态不是LISTEN */
         if (sk->sk_state != TCP_LISTEN)
             break;
         /* 信号打断 */
         err = sock_intr_errno(timeo);
         if (signal_pending(current))
             break;
         err = -EAGAIN;
         /* 调度超时 */
         if (!timeo)
             break;
     }
     /* 结束等待 */
     finish_wait(sk_sleep(sk), &wait);
     return err;
 }

reqsk_queue_remove函数完成了将完成握手的控制块从请求队列移除的工作；

 static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue,
                               struct sock *parent)
 {
     struct request_sock *req;

     spin_lock_bh(&queue->rskq_lock);

     /* 找到队列头 */
     req = queue->rskq_accept_head;
     if (req) {
         /* 减少已连接计数 */
         sk_acceptq_removed(parent);
         /* 头部指向下一节点 */
         queue->rskq_accept_head = req->dl_next;

         /* 队列为空 */
         if (queue->rskq_accept_head == NULL)
             queue->rskq_accept_tail = NULL;
     }
     spin_unlock_bh(&queue->rskq_lock);
     return req;
 }