linux内核之accept实现

  1. 用户态对accept的标准用法：  
  2. if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1)  
  3.   {  
  4.    //accept()函数让服务器接收客户的连接请求  
  5.    perror("accept Error ");  
  6.    continue;  
  7.   }  
  8. sockfd是通过socket系统调用，并且经过listen过的套接字：  
  9. sockfd = socket(AF_INET, SOCK_STREAM, 0)  
  10. listen(sockfd, 128)  
  11.   
  12. 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. }
 





【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/fengkang1008/p/4688633.html