/*

  *    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, );

 }

 /*

  *    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);