inet_csk_accept函数实现了tcp协议accept操作，其主要完成的功能是，从已经完成三次握手的队列中取控制块，如果没有已经完成的连接，则需要根据阻塞标记来来区分对待，若非阻塞则直接返回，若阻塞则需要在一定时间范围内阻塞等待；
1 /* 2 * This will accept the next outstanding connection. 3 */ 4 struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern) 5 { 6 struct inet_connection_sock *icsk = inet_csk(sk); 7 struct request_sock_queue *queue = &icsk->icsk_accept_queue; 8 struct request_sock *req; 9 struct sock *newsk; 10 int error; 11 12 lock_sock(sk); 13 14 /* We need to make sure that this socket is listening, 15 * and that it has something pending. 16 */ 17 error = -EINVAL; 18 19 /* 不是listen状态 */ 20 if (sk->sk_state != TCP_LISTEN) 21 goto out_err; 22 23 /* Find already established connection */ 24 25 /* 还没有已完成的连接 */ 26 if (reqsk_queue_empty(queue)) { 27 28 /* 获取等待时间，非阻塞为0 */ 29 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 30 31 /* If this is a non blocking socket don't sleep */ 32 error = -EAGAIN; 33 /* 非阻塞立即返回错误 */ 34 if (!timeo) 35 goto out_err; 36 37 /* 等待连接到来 */ 38 error = inet_csk_wait_for_connect(sk, timeo); 39 if (error) 40 goto out_err; 41 } 42 43 /* 从已完成连接队列中移除 */ 44 req = reqsk_queue_remove(queue, sk); 45 46 /* 设置新控制块指针 */ 47 newsk = req->sk; 48 49 /* TCP协议 && fastopen */ 50 if (sk->sk_protocol == IPPROTO_TCP && 51 tcp_rsk(req)->tfo_listener) { 52 spin_lock_bh(&queue->fastopenq.lock); 53 if (tcp_rsk(req)->tfo_listener) { 54 /* We are still waiting for the final ACK from 3WHS 55 * so can't free req now. Instead, we set req->sk to 56 * NULL to signify that the child socket is taken 57 * so reqsk_fastopen_remove() will free the req 58 * when 3WHS finishes (or is aborted). 59 */ 60 req->sk = NULL; 61 req = NULL; 62 } 63 spin_unlock_bh(&queue->fastopenq.lock); 64 } 65 out: 66 release_sock(sk); 67 68 /* 释放请求控制块 */ 69 if (req) 70 reqsk_put(req); 71 72 /* 返回找到的连接控制块 */ 73 return newsk; 74 out_err: 75 newsk = NULL; 76 req = NULL; 77 *err = error; 78 goto out; 79 }
如果请求队列中没有已完成握手的连接，并且套接字已经设置了阻塞标记，则需要加入调度队列等待连接的到来，inet_csk_wait_for_connect函数完成了这个功能；
1 /* 2 * Wait for an incoming connection, avoid race conditions. This must be called 3 * with the socket locked. 4 */ 5 static int inet_csk_wait_for_connect(struct sock *sk, long timeo) 6 { 7 struct inet_connection_sock *icsk = inet_csk(sk); 8 DEFINE_WAIT(wait); 9 int err; 10 11 /* 12 * True wake-one mechanism for incoming connections: only 13 * one process gets woken up, not the 'whole herd'. 14 * Since we do not 'race & poll' for established sockets 15 * anymore, the common case will execute the loop only once. 16 * 17 * Subtle issue: "add_wait_queue_exclusive()" will be added 18 * after any current non-exclusive waiters, and we know that 19 * it will always _stay_ after any new non-exclusive waiters 20 * because all non-exclusive waiters are added at the 21 * beginning of the wait-queue. As such, it's ok to "drop" 22 * our exclusiveness temporarily when we get woken up without 23 * having to remove and re-insert us on the wait queue. 24 */ 25 for (;;) { 26 27 /* 加入等待队列 */ 28 prepare_to_wait_exclusive(sk_sleep(sk), &wait, 29 TASK_INTERRUPTIBLE); 30 release_sock(sk); 31 32 /* 如果为空计算，进行调度 */ 33 if (reqsk_queue_empty(&icsk->icsk_accept_queue)) 34 timeo = schedule_timeout(timeo); 35 sched_annotate_sleep(); 36 lock_sock(sk); 37 err = 0; 38 /* 队列不为空*/ 39 if (!reqsk_queue_empty(&icsk->icsk_accept_queue)) 40 break; 41 err = -EINVAL; 42 /* 连接状态不是LISTEN */ 43 if (sk->sk_state != TCP_LISTEN) 44 break; 45 /* 信号打断 */ 46 err = sock_intr_errno(timeo); 47 if (signal_pending(current)) 48 break; 49 err = -EAGAIN; 50 /* 调度超时 */ 51 if (!timeo) 52 break; 53 } 54 /* 结束等待 */ 55 finish_wait(sk_sleep(sk), &wait); 56 return err; 57 }
reqsk_queue_remove函数完成了将完成握手的控制块从请求队列移除的工作；
1 static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue, 2 struct sock *parent) 3 { 4 struct request_sock *req; 5 6 spin_lock_bh(&queue->rskq_lock); 7 8 /* 找到队列头 */ 9 req = queue->rskq_accept_head; 10 if (req) { 11 /* 减少已连接计数 */ 12 sk_acceptq_removed(parent); 13 /* 头部指向下一节点 */ 14 queue->rskq_accept_head = req->dl_next; 15 16 /* 队列为空 */ 17 if (queue->rskq_accept_head == NULL) 18 queue->rskq_accept_tail = NULL; 19 } 20 spin_unlock_bh(&queue->rskq_lock); 21 return req; 22 }