码迷，mamicode.com
首页 > 系统相关 > 详细

linux内核之accept实现

时间：2015-07-30 12:56:35      阅读：450      评论：0      收藏：0      [点我收藏+]

标签：

  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.   
  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, const char *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.     else if (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. static inline void 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. static int 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. }





linux内核之accept实现

标签：

原文地址：http://www.cnblogs.com/fengkang1008/p/4688633.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！