linux内核之accept实现

1. 用户态对accept的标准用法：
2. if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1)
3. {
4. //accept()函数让服务器接收客户的连接请求
5. perror("accept Error\n");
6. continue;
7. }
8. sockfd是通过socket系统调用，并且经过listen过的套接字：
9. sockfd = socket(AF_INET, SOCK_STREAM, 0)
10. listen(sockfd, 128)
11. remote_addr将会存储远端设备的地址信息。

 

1. SYSCALL_DEFINE3(accept,int, fd,struct sockaddr __user *, upeer_sockaddr,
2. int __user *, upeer_addrlen)
3. {
4. return sys_accept4(fd, upeer_sockaddr, upeer_addrlen,0);
5. }

1. SYSCALL_DEFINE4(accept4,int, fd,struct sockaddr __user *, upeer_sockaddr,
2. int __user *, upeer_addrlen,int, flags)
3. {
4. struct socket *sock,*newsock;
5. struct file *newfile;
6. int err, len, newfd, fput_needed;
7. struct sockaddr_storage address;
9. if(flags &~(SOCK_CLOEXEC | SOCK_NONBLOCK))
10. {
11. return-EINVAL;
12. }
14. if(SOCK_NONBLOCK != O_NONBLOCK &&(flags & SOCK_NONBLOCK))
15. {
16. flags =(flags &~SOCK_NONBLOCK)| O_NONBLOCK;
17. }
19. sock = sockfd_lookup_light(fd,&err,&fput_needed);
20. if(!sock)
21. {
22. goto out;
23. }
25. err =-ENFILE;
26. newsock = sock_alloc();/*! 1.创建新的sock给新的连接 */
27. if(!newsock)
28. {
29. goto out_put;
30. }
32. newsock->type = sock->type;
33. newsock->ops = sock->ops;
35. /*
36. * We don't need try_module_get here, as the listening socket (sock)
37. * has the protocol module (sock->ops->owner) held.
38. */
39. __module_get(newsock->ops->owner);
41. newfd = get_unused_fd_flags(flags);/*! 2.分配一个fd给新的连接 */
42. if(unlikely(newfd <0))
43. {
44. err = newfd;
45. sock_release(newsock);
46. goto out_put;
47. }
48. newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);/*! 3.为newsock创建一个对应的file结构 */
49. if(unlikely(IS_ERR(newfile)))
50. {
51. err = PTR_ERR(newfile);
52. put_unused_fd(newfd);
53. sock_release(newsock);
54. goto out_put;
55. }
57. err = security_socket_accept(sock, newsock);
58. if(err)
59. {
60. goto out_fd;
61. }
63. err = sock->ops->accept(sock, newsock, sock->file->f_flags);/*! 4.调用Socket层操作函数inet_accept() */
64. if(err <0)
65. {
66. goto out_fd;
67. }
69. if(upeer_sockaddr)
70. {
71. if(newsock->ops->getname(newsock,(struct sockaddr *)&address,
72. &len,2)<0)
73. {
74. err =-ECONNABORTED;
75. goto out_fd;
76. }
77. err = move_addr_to_user(&address,
78. len, upeer_sockaddr, upeer_addrlen);
79. if(err <0)
80. {
81. goto out_fd;
82. }
83. }
85. /* File flags are not inherited via accept() unlike another OSes. */
87. fd_install(newfd, newfile);
88. err = newfd;
90. out_put:
91. fput_light(sock->file, fput_needed);
92. out:
93. return err;
94. out_fd:
95. fput(newfile);
96. put_unused_fd(newfd);
97. goto out_put;
98. }

3、sock_alloc_file()

1. struct file *sock_alloc_file(struct socket *sock,int flags,constchar*dname)
2. {
3. struct qstr name ={.name =""};
4. struct path path;
5. struct file *file;
7. if(dname)
8. {
9. name.name = dname;
10. name.len = strlen(name.name);
11. }
12. elseif(sock->sk)
13. {
14. name.name = sock->sk->sk_prot_creator->name;
15. name.len = strlen(name.name);
16. }
17. path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb,&name);
18. if(unlikely(!path.dentry))
19. {
20. return ERR_PTR(-ENOMEM);
21. }
22. path.mnt = mntget(sock_mnt);
24. d_instantiate(path.dentry, SOCK_INODE(sock));
26. file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
27. &socket_file_ops);
28. if(unlikely(IS_ERR(file)))
29. {
30. /* drop dentry, keep inode */
31. ihold(path.dentry->d_inode);
32. path_put(&path);
33. return file;
34. }
36. /*! 注意这里的属性设置 */
37. sock->file = file;
38. file->f_flags = O_RDWR |(flags & O_NONBLOCK);
39. file->private_data = sock;
40. return file;
41. }

4、inet_accept()

1. /*
2. * Accept a pending connection. The TCP layer now gives BSD semantics.
3. */
4. // <net/ipv4/af_inet.c>
5. int inet_accept(struct socket *sock,struct socket *newsock,int flags)
6. {
7. struct sock *sk1 = sock->sk;
8. int err =-EINVAL;
10. /**
11. * 如果使用的是TCP，则sk_prot为tcp_prot，accept为inet_csk_accept()
12. * 获取新连接的sock。
13. */
14. struct sock *sk2 = sk1->sk_prot->accept(sk1, flags,&err);/*! 4.1.获取新连接的sock */
16. if(!sk2)
17. {
18. goto do_err;
19. }
21. lock_sock(sk2);
23. sock_rps_record_flow(sk2);
24. WARN_ON(!((1<< sk2->sk_state)&
25. (TCPF_ESTABLISHED | TCPF_SYN_RECV |
26. TCPF_CLOSE_WAIT | TCPF_CLOSE)));
28. sock_graft(sk2, newsock);/*! 4.2.把sock和socket嫁接起来，让它们能相互索引 */
30. newsock->state = SS_CONNECTED;/*! 4.3.把新socket的状态设为已连接 */
31. err =0;
32. release_sock(sk2);
33. do_err:
34. return err;
35. }

4.2、sock_graft()

1. // <net/Sock.h>
2. staticinlinevoid sock_graft(struct sock *sk,struct socket *parent)
3. {
4. write_lock_bh(&sk->sk_callback_lock);
5. sk->sk_wq = parent->wq;
6. parent->sk = sk; /*! INET层的socket使用下层的sock服务 */
7. sk_set_socket(sk, parent);
8. security_sock_graft(sk, parent);
9. write_unlock_bh(&sk->sk_callback_lock);
10. }

4.1、inet_csk_accept()

/**

 * inet_csk_accept()用于从backlog队列（全连接队列）中取出一个ESTABLISHED状态的连接请求块，返回它所对应的连接sock。

 * 1. 非阻塞的，且当前没有已建立的连接，则直接退出，返回-EAGAIN。

 * 2. 阻塞的，且当前没有已建立的连接：

 *     2.1 用户没有设置超时时间，则无限期阻塞。

 *     2.2 用户设置了超时时间，超时后会退出。

 */

1. // <net/ipv4/Inet_connection_sock.c>
2. /*
3. * This will accept the next outstanding connection.
4. */
5. struct sock *inet_csk_accept(struct sock *sk,int flags,int*err)
6. {
7. struct inet_connection_sock *icsk = inet_csk(sk);
8. struct request_sock_queue *queue=&icsk->icsk_accept_queue;
9. struct sock *newsk;
10. struct request_sock *req;
11. int error;
13. lock_sock(sk);
15. /* We need to make sure that this socket is listening,
16. * and that it has something pending.
17. */
18. error =-EINVAL;
19. if(sk->sk_state != TCP_LISTEN)
20. {
21. goto out_err;
22. }
24. /* Find already established connection */
25. if(reqsk_queue_empty(queue))// 没有ESTABLISHED状态的连接请求块
26. {
27. long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
29. /* If this is a non blocking socket don't sleep */
30. error =-EAGAIN;
31. if(!timeo)
32. {
33. goto out_err;
34. }
36. /*! 4.1.1 阻塞等待，直到有全连接。如果用户设置有等待时间，超时后会退出 */
37. error = inet_csk_wait_for_connect(sk, timeo);
38. if(error)
39. {
40. goto out_err;
41. }
42. }
44. /*! 从全连接队列中取出第一个established状态的连接请求块 */
45. req = reqsk_queue_remove(queue);
46. newsk = req->sk;
48. sk_acceptq_removed(sk);
49. if(sk->sk_protocol == IPPROTO_TCP &&queue->fastopenq != NULL)
50. {
51. spin_lock_bh(&queue->fastopenq->lock);
52. if(tcp_rsk(req)->listener)
53. {
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. if(req)
68. {
69. __reqsk_free(req);
70. }
71. return newsk;
72. out_err:
73. newsk = NULL;
74. req = NULL;
75. *err = error;
76. goto out;
77. }

4.1.1 inet_csk_wait_for_connect()

1. // <net/ipv4/Inet_connection_sock.c>
2. /*
3. * Wait for an incoming connection, avoid race conditions. This must be called
4. * with the socket locked.
5. */
6. staticint inet_csk_wait_for_connect(struct sock *sk,long timeo)
7. {
8. struct inet_connection_sock *icsk = inet_csk(sk);
9. DEFINE_WAIT(wait);
10. int err;
12. /*
13. * True wake-one mechanism for incoming connections: only
14. * one process gets woken up, not the 'whole herd'.
15. * Since we do not 'race & poll' for established sockets
16. * anymore, the common case will execute the loop only once.
17. *
18. * Subtle issue: "add_wait_queue_exclusive()" will be added
19. * after any current non-exclusive waiters, and we know that
20. * it will always _stay_ after any new non-exclusive waiters
21. * because all non-exclusive waiters are added at the
22. * beginning of the wait-queue. As such, it's ok to "drop"
23. * our exclusiveness temporarily when we get woken up without
24. * having to remove and re-insert us on the wait queue.
25. */
26. for(;;)
27. {
28. /*! 把自己加入到等待队列，并且设置自己的状态是可中断的 */
29. prepare_to_wait_exclusive(sk_sleep(sk),&wait,
30. TASK_INTERRUPTIBLE);
31. release_sock(sk);
32. if(reqsk_queue_empty(&icsk->icsk_accept_queue))
33. {
34. /**
35. * 用户发起的accept操作就停schedule_timeout中
36. * switch (timeout)
37. * {
38. * case MAX_SCHEDULE_TIMEOUT:
39. * schedule();
40. * goto out;
41. * default:
42. * }
43. * 根据其实现代码，由于我们一般没有设置timeout值，所以是MAX_SCHEDULE_TIMEOUT的情况，这表示立即进入重新调度，
44. * 而当前的进程可以处于睡眠，直到被其它事件唤醒。
45. */
46. timeo = schedule_timeout(timeo);
47. }
48. sched_annotate_sleep();
49. lock_sock(sk);
50. err =0;
51. if(!reqsk_queue_empty(&icsk->icsk_accept_queue))
52. {
53. break;
54. }
55. err =-EINVAL;
56. if(sk->sk_state != TCP_LISTEN)
57. {
58. break;
59. }
60. err = sock_intr_errno(timeo);
61. if(signal_pending(current))
62. {
63. break;
64. }
65. err =-EAGAIN;
66. if(!timeo)
67. {
68. break;
69. }
70. }
71. /*! 下面把任务设置成TASK_RUNNING状态，然后把当前sock从等待队列中删除 */
72. finish_wait(sk_sleep(sk),&wait);
73. return err;
74. }

 

来自为知笔记(Wiz)