accept系统调用内核实现

时间:2024-04-04 22:34:40
用户态对accept的标准使用方法:
if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1)
{
//accept()函数让server接收客户的连接请求
perror("accept Error\n");
continue;
}
sockfd是通过socket系统调用,而且经过listen过的套接字:
sockfd = socket(AF_INET, SOCK_STREAM, 0)
listen(sockfd, 128) remote_addr将会存储远端设备的地址信息。 /*
* For accept, we attempt to create a new socket, set up the link
* with the client, wake up the client, then return the new
* connected fd. We collect the address of the connector in kernel
* space and move it to user at the very end. This is unclean because
* we open the socket then return an error.
*
* 1003.1g adds the ability to recvmsg() to query connection pending
* status to recvmsg. We need to add that support in a way thats
* clean when we restucture accept also.
*/ asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
int __user *upeer_addrlen)
{
struct socket *sock, *newsock;
struct file *newfile;
int err, len, newfd, fput_needed;
char address[MAX_SOCK_ADDR]; //通过监听套接字的描写叙述符fd,找到监听套接字
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (!sock)
goto out; err = -ENFILE;
//创建新的socket,即心的套接字,它将被client_fd 描写叙述,用于数据传输,
//也就是accept系统调用返回值client_fd 所相应的套接口
if (!(newsock = sock_alloc()))
goto out_put; //继承listen_fd相应的的一些属性,包含套接字类型,和操作。
//不难理解,listen_fd和client_fd 相应的套接口都是tcp,这些不用一一赋值,直接用listen_fd的属性就可以。
newsock->type = sock->type;
newsock->ops = sock->ops; /*
* We don't need try_module_get here, as the listening socket (sock)
* has the protocol module (sock->ops->owner) held.
*/
//不懂
__module_get(newsock->ops->owner); //创建新的file,然后返回newfd ,这个fd就是待会被返回的client_fd
//到如今为止,这个newfd和newfile是有关联的。
newfd = sock_alloc_fd(&newfile);
if (unlikely(newfd < 0)) {
err = newfd;
sock_release(newsock);
goto out_put;
}
//使得这个newsock绑定刚才新建的newfile
//即如今为止,newfd newfile newsock之间是有关联的
err = sock_attach_fd(newsock, newfile);
if (err < 0)
goto out_fd_simple; err = security_socket_accept(sock, newsock);
if (err)
goto out_fd;
//newsock是socket结构体,sock->ops->accept的目的是为newsock关联一个sock结构体
//即三次握手结束后,新建的sock传输控制块,它等待用户accept系统调用“领养”它。
//sock->ops->accept相应的函数是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;
}
err = move_addr_to_user(address, len, upeer_sockaddr,
upeer_addrlen);
if (err < 0)
goto out_fd;
}
.........................................
} /*
* Accept a pending connection. The TCP layer now gives BSD semantics.
*/
int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{
//第一个參数sock是监听套接字代表的套接字
//newsock是刚才我们新建的套接字,用以描写叙述数据传输
//显然,此函数的目的,是找到通过套接字,找到套接字上挂着的以及完毕三次握手的sk
//这个被找到的sk,将被关联到newsock //sk1 是监听套接字相应的传输控制块
struct sock *sk1 = sock->sk;
int err = -EINVAL; //sk2(三次握手后建立的传输控制块) 是挂在sk1(监听套接字的传输控制块) 中的完毕三次握手后的sk
// sk1->sk_prot->accept 相应的函数是inet_csk_accept
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))); //这个被找到的sk,将被关联到newsock
//三次握手后建立的传输控制块sk(sock 结构体),是不正确应不论什么socket结构体的,所以我们关联上
//这样三次握手后建立的传输控制块sk,就和文件系统有关联了
//关联上后,我们就能对其调用send,recvfrom等系统调用了
sock_graft(sk2, newsock); newsock->state = SS_CONNECTED;
err = 0;
release_sock(sk2);
do_err:
return err;
} /*
* This will accept the next outstanding connection.
*/
//inet_csk_accept的功能时获取建立3次握手后的sk,一次调用返回一个sk
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;
//假设你传进的參数正确,监听套接字相应的传输控制块的状态,肯定是TCP_LISTEN
if (sk->sk_state != TCP_LISTEN)
goto out_err; /* Find already established connection */
//icsk->icsk_accept_queue挂的是request_sock,request_sock上挂的就是三次握手后新建的sk
//reqsk_queue_empty(&icsk->icsk_accept_queue)推断是否空,就进入if,怎样设置为堵塞,则休眠
if (reqsk_queue_empty(&icsk->icsk_accept_queue)) {
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;
} //reqsk_queue_get_child的逻辑是:
//1:取出icsk_accept_queue的request_sock,然后取出request_sock中的sk
//2:listen的sk中,sk_ack_backlog计数减一,sk->sk_ack_backlog--,由于sk_ack_backlog有上限。
//3:删除request_sock
//4:return取出的sk
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;
}