本文主要介绍了accept()的系统调用、Socket层实现,以及TCP层实现。

内核版本:3.6

Author:zhangskd @ csdn blog

应用层

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

It extracts the first connection request on the queue of pending connections (backlog), creates a new

connected socket, and returns a new file descriptor referring to that socket.

If no pending connections are present on the queue, and the socket is not marked as non-blocking,

accept() blocks the caller until a connection is present. If the socket is marked non-blocking and no

pending connections are present on the queue, accept() fails with the error EAGAIN.

在建立好接收队列以后,服务器就调用accept(),然后睡眠直到有客户端的连接请求到达。

addr用于保存客户端的地址。

系统调用

accept()是由glibc提供的,声明位于include/sys/socket.h中,实现位于sysdeps/mach/hurd/accept.c中,

主要是用来从用户空间进入名为sys_socketcall的系统调用,并传递参数。sys_socketcall()实际上是所有

socket函数进入内核空间的共同入口。

在sys_socketcall()中会调用sys_accept4()。

SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
{
...
switch(call) {
...
case SYS_ACCEPT:
err = sys_accpet4(a0, (struct sockaddr __user *)a1, (int __user *)a[2], 0);
break;
...
}
return err;
}

经过了socket层的总入口sys_socketcall(),现在进入sys_accpet4()。

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; /* 只允许使用这两个标志 */
if (flags & ~(SOCK_CLOSEXEC | SOCK_NONBLOCK))
return -EINVAL; if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; /* 通过文件描述符fd,找到对应的socket。
* 以fd为索引从当前进程的文件描述符表files_struct中找到对应的file实例,
* 然后从file实例的private_data成员中获取socket实例。
*/
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (! sock)
goto out; err = -ENFILE; /* File table overflow */
newsock = sock_alloc(); /* 创建一个新的inode和socket */
if (! newsock)
goto out_put; newsock->type = sock->type; /* 新socket的类型 */
newsock->ops = sock->ops; /* 新socket的socket层操作 */ /* We don't need try_module_get here, as the listening socket (sock)
* has the protocol module (sock->ops->owner) held.
* Socekt层协议,对SOCK_STREAM来说是inet_stream_ops,它的引用计数加一。
*/
__module_get(newsock->ops->owner); /* 为socket创建一个对应的file结构sock->file,返回fd */
newfd = sock_alloc_file(newsock, &newfile, flags);
if (unlikely(newfd < 0)) {
err = newfd;
sock_release(newsock);
goto out_put;
} err = security_socket_accept(sock, newsock); /* SELinux相关 */
if (err)
goto out_fd; /* SOCKET层的操作函数,如果是SOCK_STREAM,proto_ops为inet_stream_ops,
* 接下来调用inet_accept()。
*/
err = sock->ops->accept(sock, newsock, sock->file->f_flags);
if (err < 0)
goto out_fd; if (upeer_sockaddr) { /* 如果要保存对端地址 */
/* 获取对端的地址,以及地址的长度 */
if (newsock->ops->getname(newsock, (struct sockaddr *)&address, &len, 2) < 0) {
err = -ECONNABORTED; /* Software caused connection abort */
goto out_fd;
} /* 把内核空间的socket地址复制到用户空间 */
err = move_addr_to_user(&address, len, upeer_sockaddr, upeer_addrlen);
if (err < 0)
goto out_fd;
} /* File flags are not inherited via accept() unlike another OSes.
* 以newfd为索引,把newfile加入当前进程的文件描述符表files_struct中。
*/
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;
}

sys_accept4()主要做了:

1. 创建了一个新的socket和inode,以及它所对应的fd、file。

2. 调用Socket层操作函数inet_accept()。

3. 保存对端地址到指定的用户空间地址。

Socket层

SOCK_STREAM套接口的Socket层操作函数集实例为inet_stream_ops,连接接收函数为inet_accept()。

const struct proto_ops inet_stream_ops = {
.family = PF_INET,
.owner = THIS_MODULE,
...
.accept = inet_accept,
...
};

inet_accept()主要做了:

1. 调用TCP层的操作函数,获取已建立的连接sock。

2. 把新socket和sock关联起来。

3. 把新socket的状态设为SS_CONNECTED。

至此,新socket的各个字段都赋值完毕了。

/* Accept a pending connection.
* The TCP layer now gives BSD semantics.
*/
int inet_accept(struct socket *sock, struct socket *newsock, int flags)
{ struct sock *sk1 = sock->sk;
int err = -EINVAL; /* 如果使用的是TCP,则sk_prot为tcp_prot,accept为inet_csk_accept()
* 获取新连接的sock。
*/
struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);
if (! sk2)
goto do_err; lock_sock(sk2); sock_rps_record_flow(sk2); /* RPS补丁 */
WARN_ON(! ((1 << sk2->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE))); sock_graft(sk2, newsock); /* 把sock和socket嫁接起来,让它们能相互索引 */
newsock->state = SS_CONNECTED; /* 把新socket的状态设为已连接 */ err = 0;
release_sock(sk2); do_err:
return err;
}
/*
* struct callback_head - callback structure for use with RCU and task_work
* @next: next update requests in a list
* @func: actual update function to call after the grace period.
*/
struct callback_head {
struct callback_head *next;
void (*func) (struct callback_head *head);
};
#define rcu_head callback_head /* 把sock和socket嫁接起来。*/
static inline void sock_graft(struct sock *sk, struct socket *parent)
{
write_lock_bh(&sk->sk_callback_lock); sk->sk_wq = parent->wq; /* 等待队列 */
parent->sk = sk;
sk_set_socket(sk, parent);
security_sock_graft(sk, parent); write_unlock_bh(&sk->sk_callback_lock);
} static inline void sk_set_socket(struct sock *sk, struct socket *sock)
{
sk_tx_queue_clear(sk);
sk->sk_socket = sock;
}

TCP层实现

SOCK_STREAM套接口的TCP层操作函数集实例为tcp_prot,其中连接接收函数为inet_csk_accept()。

struct proto tcp_prot = {
.name = "TCP",
.owner = THIS_MODULE,
...
.accept = inet_csk_accept,
...
};

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

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

2. 阻塞的,且当前没有已建立的连接:

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

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

/* This will accept the next outstanding connection. */
struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
{
struct inet_connection_sock *icsk = inet_csk(sk);
struct sock *newsk;
int error; lock_sock(sk); /* We need to make sure that this socket is listening,
* and that it has something pending.
*/
error = -EINVAL; if (sk->sk_state != TCP_LISTEN) /* socket必须处于监听状态 */
goto out_err; /* Find already established connection.
* 发没有现ESTABLISHED状态的连接请求块。
*/
if (reqsk_queue_empty(&icsk->icsk_accept_queue)) { /* 等待超时时间,如果是非阻塞则为0 */
long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); /* If this is a non blocking socket don't sleep */
error = -EAGAIN; /* Try again */ if (! timeo) /* 如果是非阻塞的,则直接退出 */
goto out_err; /* 阻塞等待,直到有全连接。如果用户有设置等待超时时间,超时后会退出 */
error = inet_csk_wait_for_connect(sk, timeo); if (error)
goto out_err;
} /* 获取新连接的sock,释放连接控制块 */
newsk = reqsk_queue_get_child(&icsk->icsk_accept_queue, sk);
WARN_ON(newsk->sk_state == TCP_SYN_RECV); out:
release_sock(sk);
return newsk; out err:
newsk = NULL;
*err = error;
goto out;
}

检查ESTABLISHED状态的连接请求块队列是否为空。

static inline int reqsk_queue_empty(struct request_sock_queue *queue)
{
return queue->rskq_accept_head == NULL;
} static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
{
return noblock ? 0 : sk->sk_rcvtimeo; /* accept()超时时间 */
}

从backlog队列(全连接队列)中取出一个ESTABLISHED状态的连接请求块,返回它所对应的连接sock。

同时更新backlog队列的全连接数,释放取出的连接控制块。

static inline struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
struct sock *parent)
{
/* 从全连接队列中,取出第一个ESTABLISHED状态的连接请求块 */
struct request_sock *req = reqsk_queue_remove(queue);
struct sock *child = req->sk; /* 一个已建立的连接 */ WARN_ON(child == NULL); sk_acceptq_removed(parent); /* 当前backlog队列的全连接数减一 */
__reqsk_free(req); /* 释放取出的连接请求控制块 */ return child;
} static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
{
struct request_sock *req = queue->rskq_accept_head; /* 第一个ESTABLISHED状态的连接请求块 */
WARN_ON(req == NULL); queue->rskq_accept_head = req->dl_next; if (queue->rskq_accept_head == NULL)
queue->rskq_accept_tail = NULL; return req;
} static inline void sk_acceptq_removed(struct sock *sk)
{
sk->sk_ack_backlog--; /* 全连接的数量减一 */
} /* 释放连接请求控制块 */
static inline void __reqsk_free(struct request_sock *req)
{
kmem_cache_free(req->rsk_ops->slab, req);
}

Socket层实现系列 — accept()的实现(一)的更多相关文章

  1. Socket层实现系列 — accept()的实现(二)

    本文主要分析accept()的阻塞等待和唤醒. 内核版本:3.6 Author:zhangskd @ csdn blog 等待队列 (1)socket的等待队列 /* * @sk_wq: sock w ...

  2. Socket层实现系列 — 睡眠驱动的同步等待

    主要内容:Socket的同步等待机制,connect和accept等待的实现. 内核版本:3.15.2 我的博客:http://blog.csdn.net/zhangskd 概述 socket上定义了 ...

  3. Socket层实现系列 — listen()的实现

    本文主要分析listen()的内核实现,包括它的系统调用.Socket层实现.半连接队列,以及监听哈希表. 内核版本:3.6 Author:zhangskd @ csdn blog 应用层 int l ...

  4. Socket层实现系列 — bind()的实现(一)

    bind()函数的使用方法很简单,但是它是怎么实现的呢? 笔者从应用层出发,沿着网络协议栈,分析了bind()的系统调用.Socket层实现,以及它的TCP层实现. 本文主要内容:bind()的系统调 ...

  5. Socket层实现系列 — send()类发送函数的实现

    主要内容:socket发送函数的系统调用.Socket层实现. 内核版本:3.15.2 我的博客:http://blog.csdn.net/zhangskd 发送流程图 以下是send().sendt ...

  6. Socket层实现系列 — connect()的实现

    主要内容:connect()的Socket层实现.期间进程的睡眠和唤醒. 内核版本:3.15.2 我的博客:http://blog.csdn.net/zhangskd 应用层 int connect( ...

  7. Socket层实现系列 — 信号驱动的异步等待

    主要内容:Socket的异步通知机制. 内核版本:3.15.2 我的博客:http://blog.csdn.net/zhangskd 概述 socket上定义了几个IO事件:状态改变事件.有数据可读事 ...

  8. Socket层实现系列 — getsockname()和getpeername()的实现

    本文主要介绍了getsockname()和getpeername()的内核实现. 内核版本:3.6 Author:zhangskd @ csdn blog 应用层 int getsockname(in ...

  9. Socket层实现系列 — I/O事件及其处理函数

    主要内容:Socket I/O事件的定义.I/O处理函数的实现. 内核版本:3.15.2 我的博客:http://blog.csdn.net/zhangskd I/O事件定义 sock中定义了几个I/ ...

随机推荐

  1. 1.cocos2dx 3.2环境搭建

    1        所需软件 jdk-7u25-windows-i586.exe python-2.7.8.amd64.msi cocos2d-x-3.2.zip apache-ant-1.9.4.zi ...

  2. Cocos2D在新版Swift中常量枚举值引用代码的修改

    大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请多提意见,如果觉得不错请多多支持点赞.谢谢! hopy ;) 我们知道在SpriteBuilder中是无法直接给一个CCB文 ...

  3. mysql-workbench工具update(更新)失败的解决办法

    是因为安全模式的保护,所以我们需要设置一下: 如下:windows下是edit–>preferences–>SQL Editor 把右边的最后一行,"safe update&qu ...

  4. [ExtJS5学习笔记]第二十节 Extjs5配合数组的push方法,动态创建并加载组件

    本文地址:http://blog.csdn.net/sushengmiyan/article/details/39226773 官方例子:http://docs.sencha.com/extjs/5. ...

  5. Android简易实战教程--第十六话《SharedPreferences保存用户名和密码》

    之前在Android简易实战教程--第七话<在内存中存储用户名和密码> 那里是把用户名和密码保存到了内存中,这一篇把用户名和密码保存至SharedPreferences文件.为了引起误导, ...

  6. cocos2dx 3.3 C++工程添加lua支持

    准备工作: 1. 拷贝cocos2d-x-3.3rc0\external\lua整个文件夹到项目中(如myProject\cocos2d\external\lua) 2. 拷贝cocos2d-x-3. ...

  7. Intellij IDEA插件开发入门

    现今的IDE尽管有如"洪水猛兽"般强大,但要知道再强大的IDE也没法提供给使用者想要的一切功能, 所以IDE一般都提供有API接口供开发者自行扩展.下面以Intellij IDEA ...

  8. Swift基础之闭包Closure学习

    首先Swift语言中没有了Block内容,但是你可以通过调用OC文件使用,也可以使用Closure(闭包),实现Block或者Delegae同样反向传值或回调函数的效果,也可以解决函数指针的问题,两者 ...

  9. 最简单的基于FFmpeg的内存读写的例子:内存播放器

    ===================================================== 最简单的基于FFmpeg的内存读写的例子系列文章列表: 最简单的基于FFmpeg的内存读写的 ...

  10. pig加载两个不同字段个数的文件?load file with different items(f1有42列,f2有43列读到一个对象中)

    我文章提到,加载一个文件的部分列是可行.两列,你只读一列,没问题. 但是,两个文件,f1和f2,f1有42列,f2有43列,同时加载到一个流对象,如何? 答:成功加载.但是无结构(schema unk ...