本文主要介绍了accept()的系统调用、Socket层实现，以及TCP层实现。
内核版本：3.6
Author：zhangskd @ csdn blog
应用层
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
It extracts the first connection request on the queue of pending connections (backlog), creates a new
connected socket, and returns a new file descriptor referring to that socket.
If no pending connections are present on the queue, and the socket is not marked as non-blocking,
accept() blocks the caller until a connection is present. If the socket is marked non-blocking and no
pending connections are present on the queue, accept() fails with the error EAGAIN.
在建立好接收队列以后，服务器就调用accept()，然后睡眠直到有客户端的连接请求到达。
addr用于保存客户端的地址。
系统调用
accept()是由glibc提供的，声明位于include/sys/socket.h中，实现位于sysdeps/mach/hurd/accept.c中，
主要是用来从用户空间进入名为sys_socketcall的系统调用，并传递参数。sys_socketcall()实际上是所有
socket函数进入内核空间的共同入口。
在sys_socketcall()中会调用sys_accept4()。
SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
{
...
switch(call) {
...
case SYS_ACCEPT:
err = sys_accpet4(a0, (struct sockaddr __user *)a1, (int __user *)a[2], 0);
break;
...
}
return err;
}
经过了socket层的总入口sys_socketcall()，现在进入sys_accpet4()。
SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
int __user *, upeer_addrlen, int flags)
{
struct socket *sock, *newsock;
struct file *newfile;
int err, len, newfd, fput_needed;
struct sockaddr_storage address;
/* 只允许使用这两个标志 */
if (flags & ~(SOCK_CLOSEXEC | SOCK_NONBLOCK))
return -EINVAL;
if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
/* 通过文件描述符fd，找到对应的socket。
* 以fd为索引从当前进程的文件描述符表files_struct中找到对应的file实例，
* 然后从file实例的private_data成员中获取socket实例。
*/
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (! sock)
goto out;
err = -ENFILE; /* File table overflow */
newsock = sock_alloc(); /* 创建一个新的inode和socket */
if (! newsock)
goto out_put;
newsock->type = sock->type; /* 新socket的类型 */
newsock->ops = sock->ops; /* 新socket的socket层操作 */
/* We don't need try_module_get here, as the listening socket (sock)
* has the protocol module (sock->ops->owner) held.
* Socekt层协议，对SOCK_STREAM来说是inet_stream_ops，它的引用计数加一。
*/
__module_get(newsock->ops->owner);
/* 为socket创建一个对应的file结构sock->file，返回fd */
newfd = sock_alloc_file(newsock, &newfile, flags);
if (unlikely(newfd < 0)) {
err = newfd;
sock_release(newsock);
goto out_put;
}
err = security_socket_accept(sock, newsock); /* SELinux相关 */
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; /* Software caused connection abort */
goto out_fd;
}
/* 把内核空间的socket地址复制到用户空间 */
err = move_addr_to_user(&address, len, upeer_sockaddr, upeer_addrlen);
if (err < 0)
goto out_fd;
}
/* File flags are not inherited via accept() unlike another OSes.
* 以newfd为索引，把newfile加入当前进程的文件描述符表files_struct中。
*/
fd_install(newfd, newfile);
err = newfd;
out_put:
fput_light(sock->file, fput_needed);
out:
return err;
out_fd:
fput(newfile);
put_unused_fd(newfd);
goto out_put;
}
sys_accept4()主要做了：
1. 创建了一个新的socket和inode，以及它所对应的fd、file。
2. 调用Socket层操作函数inet_accept()。
3. 保存对端地址到指定的用户空间地址。
Socket层
SOCK_STREAM套接口的Socket层操作函数集实例为inet_stream_ops，连接接收函数为inet_accept()。
const struct proto_ops inet_stream_ops = {
.family = PF_INET,
.owner = THIS_MODULE,
...
.accept = inet_accept,
...
};
inet_accept()主要做了：
1. 调用TCP层的操作函数，获取已建立的连接sock。
2. 把新socket和sock关联起来。
3. 把新socket的状态设为SS_CONNECTED。
至此，新socket的各个字段都赋值完毕了。
/* Accept a pending connection.
* The TCP layer now gives BSD semantics.
*/
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);
sock_rps_record_flow(sk2); /* RPS补丁 */
WARN_ON(! ((1 << sk2->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE)));
sock_graft(sk2, newsock); /* 把sock和socket嫁接起来，让它们能相互索引 */
newsock->state = SS_CONNECTED; /* 把新socket的状态设为已连接 */
err = 0;
release_sock(sk2);
do_err:
return err;
}
/*
* struct callback_head - callback structure for use with RCU and task_work
* @next: next update requests in a list
* @func: actual update function to call after the grace period.
*/
struct callback_head {
struct callback_head *next;
void (*func) (struct callback_head *head);
};
#define rcu_head callback_head
/* 把sock和socket嫁接起来。*/
static inline void sock_graft(struct sock *sk, struct socket *parent)
{
write_lock_bh(&sk->sk_callback_lock);
sk->sk_wq = parent->wq; /* 等待队列 */
parent->sk = sk;
sk_set_socket(sk, parent);
security_sock_graft(sk, parent);
write_unlock_bh(&sk->sk_callback_lock);
}
static inline void sk_set_socket(struct sock *sk, struct socket *sock)
{
sk_tx_queue_clear(sk);
sk->sk_socket = sock;
}
TCP层实现
SOCK_STREAM套接口的TCP层操作函数集实例为tcp_prot，其中连接接收函数为inet_csk_accept()。
struct proto tcp_prot = {
.name = "TCP",
.owner = THIS_MODULE,
...
.accept = inet_csk_accept,
...
};
inet_csk_accept()用于从backlog队列（全连接队列）中取出一个ESTABLISHED状态的连接请求块，返回它所对应的连接sock。
1. 非阻塞的，且当前没有已建立的连接，则直接退出，返回-EAGAIN。
2. 阻塞的，且当前没有已建立的连接：
2.1 用户没有设置超时时间，则无限期阻塞。
2.2 用户设置了超时时间，超时后会退出。
/* This will accept the next outstanding connection. */
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);
/* We need to make sure that this socket is listening,
* and that it has something pending.
*/
error = -EINVAL;
if (sk->sk_state != TCP_LISTEN) /* socket必须处于监听状态 */
goto out_err;
/* Find already established connection.
* 发没有现ESTABLISHED状态的连接请求块。
*/
if (reqsk_queue_empty(&icsk->icsk_accept_queue)) {
/* 等待超时时间，如果是非阻塞则为0 */
long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
/* If this is a non blocking socket don't sleep */
error = -EAGAIN; /* Try again */
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;
}
检查ESTABLISHED状态的连接请求块队列是否为空。
static inline int reqsk_queue_empty(struct request_sock_queue *queue)
{
return queue->rskq_accept_head == NULL;
}
static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
{
return noblock ? 0 : sk->sk_rcvtimeo; /* accept()超时时间 */
}
从backlog队列（全连接队列）中取出一个ESTABLISHED状态的连接请求块，返回它所对应的连接sock。
同时更新backlog队列的全连接数，释放取出的连接控制块。
static inline struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
struct sock *parent)
{
/* 从全连接队列中，取出第一个ESTABLISHED状态的连接请求块 */
struct request_sock *req = reqsk_queue_remove(queue);
struct sock *child = req->sk; /* 一个已建立的连接 */
WARN_ON(child == NULL);
sk_acceptq_removed(parent); /* 当前backlog队列的全连接数减一 */
__reqsk_free(req); /* 释放取出的连接请求控制块 */
return child;
}
static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
{
struct request_sock *req = queue->rskq_accept_head; /* 第一个ESTABLISHED状态的连接请求块 */
WARN_ON(req == NULL);
queue->rskq_accept_head = req->dl_next;
if (queue->rskq_accept_head == NULL)
queue->rskq_accept_tail = NULL;
return req;
}
static inline void sk_acceptq_removed(struct sock *sk)
{
sk->sk_ack_backlog--; /* 全连接的数量减一 */
}
/* 释放连接请求控制块 */
static inline void __reqsk_free(struct request_sock *req)
{
kmem_cache_free(req->rsk_ops->slab, req);
}