accept系统调用

accept系统调用完成的工作是，从已经完成三次握手的连接队列中取一个连接，进行后续服务；

调用过程中，会重新分配一个socket，以及关联文件和传输控制块，如果应用层需要获取对端信息，则将对端信息拷贝到用户空间；

 /*
  *    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.
  */

 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;

     /* 只支持cloexec和nonblock */
     if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
         return -EINVAL;

     /* 如果阻塞标记不等&& 有阻塞标记，则替换为O_NONBLOCK */
     if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
         flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;

     /* 找到socket */
     sock = sockfd_lookup_light(fd, &err, &fput_needed);
     if (!sock)
         goto out;

     err = -ENFILE;

     /* 分配一个新socket */
     newsock = sock_alloc();
     if (!newsock)
         goto out_put;

     /* 类型和操作与本端socket相同 */
     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);

     /* 获取新的文件描述符 */
     newfd = get_unused_fd_flags(flags);
     if (unlikely(newfd < )) {
         err = newfd;
         sock_release(newsock);
         goto out_put;
     }

     /* 分配新的文件 */
     newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
     if (IS_ERR(newfile)) {
         err = PTR_ERR(newfile);
         put_unused_fd(newfd);
         sock_release(newsock);
         goto out_put;
     }

     /* accept检查 */
     err = security_socket_accept(sock, newsock);
     if (err)
         goto out_fd;

     /* 执行具体的accept操作 */
     err = sock->ops->accept(sock, newsock, sock->file->f_flags, false);
     if (err < )
         goto out_fd;

     /* 指定了获取对端信息 */
     if (upeer_sockaddr) {
         if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
                       &len, ) < ) {
             err = -ECONNABORTED;
             goto out_fd;
         }

         /* 拷贝对端地址到用户空间结构 */
         err = move_addr_to_user(&address,
                     len, upeer_sockaddr, upeer_addrlen);
         if (err < )
             goto out_fd;
     }

     /* File flags are not inherited via accept() unlike another OSes. */

     /* 绑定描述符和文件 */
     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;
 }

 SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
         int __user *, upeer_addrlen)
 {
     return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, );
 }

inet_accept函数调用传输层的accept操作，并且返回新的连接控制块，新的连接控制块需要与新的socket进行关联，accept完成，将新socket的状态设置为已连接状态；

 /*
  *    Accept a pending connection. The TCP layer now gives BSD semantics.
  */

 int inet_accept(struct socket *sock, struct socket *newsock, int flags,
         bool kern)
 {
     struct sock *sk1 = sock->sk;
     int err = -EINVAL;

     /* 执行传输层的accept操作 */
     struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err, kern);

     if (!sk2)
         goto do_err;

     lock_sock(sk2);

     /* rps处理 */
     sock_rps_record_flow(sk2);
     WARN_ON(!(( << sk2->sk_state) &
           (TCPF_ESTABLISHED | TCPF_SYN_RECV |
           TCPF_CLOSE_WAIT | TCPF_CLOSE)));

     /* 控制块连接到新的socket */
     sock_graft(sk2, newsock);

     /* 设置新socket的状态为连接 */
     newsock->state = SS_CONNECTED;
     err = ;
     release_sock(sk2);
 do_err:
     return err;
 }
 EXPORT_SYMBOL(inet_accept);

TCP层对于accept的实现，请移步另外一篇文章：<TCP层accept系统调用的实现分析>；