1、socket的直接创建
cpp
net/socket.c
SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
{
...
retval = sock_create(family, type, protocol, &sock);
...
}
int sock_create(int family, int type, int protocol, struct socket **res)
{
return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}
int __sock_create(struct net *net, int family, int type, int protocol,
struct socket **res, int kern)
{
int err;
struct socket *sock;
const struct net_proto_family *pf;
...
//分配socket对象
sock = sock_alloc();
...
//获取对应协议簇的操作表
pf = rcu_dereference(net_families[family]);
...
//调用协议簇的创建函数,对于AF_INET对应的是inet_create,这个函数在inet_init函数中被初始化
err = pf->create(net, sock, protocol, kern);
...
}
EXPORT_SYMBOL(__sock_create);
socket在内核中是怎么创建的?
sock_create->__sock_create->inet_create
在__sock_create里首先调用sock_alloc来分配一个struct sock内核对象,接着获取协议簇的操作函数表,调用其create方法。对于AF_INET协议簇来说,执行到的是inet_create函数。
cpp
static int inet_create(struct net *net, struct socket *sock, int protocol,
int kern)
{
struct sock *sk; // 指向 sock 结构体,表示套接字
struct inet_protosw *answer; // 指向 inet_protosw 结构体,表示协议开关
struct inet_sock *inet; // 指向 inet_sock 结构体,表示 IPv4 套接字
struct proto *answer_prot; // 指向 proto 结构体,表示协议操作
unsigned char answer_flags; // 协议开关标志
int try_loading_module = 0; // 尝试加载模块的次数
int err; // 用于存储函数返回值
/*
* 检查协议号是否在有效范围内。
* 如果不在,返回 -EINVAL 错误。
*/
if (protocol < 0 || protocol >= IPPROTO_MAX)
return -EINVAL;
/*
* 初始化套接字状态为未连接。
*/
sock->state = SS_UNCONNECTED;
/*
* 查找请求的类型/协议对。
* 首先尝试在 RCU 读锁保护下查找协议。
*/
lookup_protocol:
err = -ESOCKTNOSUPPORT; // 设置错误为"不支持的套接字类型"
rcu_read_lock(); // 锁定 RCU 读锁
/*
* 遍历协议开关列表,查找匹配的协议。
* 如果找到匹配的协议,跳出循环。
*/
list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
if (protocol == answer->protocol) {
if (protocol != IPPROTO_IP)
break;
} else {
if (IPPROTO_IP == protocol) {
protocol = answer->protocol;
break;
}
if (IPPROTO_IP == answer->protocol)
break;
}
err = -EPROTONOSUPPORT; // 设置错误为"不支持的协议"
}
/*
* 如果没有找到匹配的协议,尝试加载相应的模块。
* 如果模块加载后,再次尝试查找协议。
*/
if (unlikely(err)) {
if (try_loading_module < 2) {
rcu_read_unlock(); // 解锁 RCU 读锁
if (++try_loading_module == 1)
request_module("net-pf-%d-proto-%d-type-%d",
PF_INET, protocol, sock->type);
else
request_module("net-pf-%d-proto-%d",
PF_INET, protocol);
goto lookup_protocol; // 重新查找协议
} else {
goto out_rcu_unlock; // 如果模块加载失败,跳转到错误处理
}
}
/*
* 检查是否允许非内核进程创建原始套接字。
* 如果不允许,返回 -EPERM 错误。
*/
err = -EPERM;
if (sock->type == SOCK_RAW && !kern &&
!ns_capable(net->user_ns, CAP_NET_RAW))
goto out_rcu_unlock;
/*
* 设置套接字的操作函数和协议。
*/
sock->ops = answer->ops;
//获得tcp_port
answer_prot = answer->prot;
answer_flags = answer->flags;
rcu_read_unlock(); // 解锁 RCU 读锁
/*
* 分配套接字内存。
* 如果分配失败,返回 -ENOBUFS 错误。
*/
err = -ENOBUFS;
sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);
if (!sk)
goto out;
/*
* 初始化套接字。
*/
err = 0;
if (INET_PROTOSW_REUSE & answer_flags)
sk->sk_reuse = SK_CAN_REUSE; // 设置套接字重用标志
inet = inet_sk(sk); // 获取 IPv4 套接字结构体
inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0; // 设置是否为控制套接字
// 初始化其他 IPv4 特定字段
inet->nodefrag = 0;
if (SOCK_RAW == sock->type) {
inet->inet_num = protocol;
if (IPPROTO_RAW == protocol)
inet->hdrincl = 1;
}
if (net->ipv4.sysctl_ip_no_pmtu_disc)
inet->pmtudisc = IP_PMTUDISC_DONT;
else
inet->pmtudisc = IP_PMTUDISC_WANT;
inet->inet_id = 0;
// 关联套接字和协议
sock_init_data(sock, sk);
sk->sk_destruct = inet_sock_destruct;
sk->sk_protocol = protocol;
sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
inet->uc_ttl = -1;
inet->mc_loop = 1;
inet->mc_ttl = 1;
inet->mc_all = 1;
inet->mc_index = 0;
inet->mc_list = NULL;
inet->rcv_tos = 0;
sk_refcnt_debug_inc(sk); // 增加套接字引用计数
// 如果设置了特定协议号,添加到协议哈希链
if (inet->inet_num) {
err = sk->sk_prot->hash(sk);
if (err) {
sk_common_release(sk);
goto out;
}
}
// 如果协议需要,调用协议的初始化函数
if (sk->sk_prot->init) {
err = sk->sk_prot->init(sk);
if (err) {
sk_common_release(sk);
goto out;
}
}
// 对于非内核进程,运行 BPF cgroup 套接字挂钩程序
if (!kern) {
err = BPF_CGROUP_RUN_PROG_INET_SOCK(sk);
if (err) {
sk_common_release(sk);
goto out;
}
}
out:
return err; // 返回结果
out_rcu_unlock:
rcu_read_unlock(); // 解锁 RCU 读锁
goto out; // 跳转到函数出口
}
在inet_create中根据类型SOCK_STREAM查找到对于TCP定义的操作方法实现集合inet_stream_ops和tcp_port,并把它们分别设置到socket->ops和sock->sk_port上。
cpp
void sock_init_data(struct socket *sock, struct sock *sk)
{
/* 初始化套接字通用字段 */
sk_init_common(sk);
...
/* 设置套接字的接收和发送缓冲区大小 */
sk->sk_rcvbuf = sysctl_rmem_default; // 接收缓冲区默认大小
sk->sk_sndbuf = sysctl_wmem_default; // 发送缓冲区默认大小
...
/* 设置套接字状态为 TCP_CLOSE(关闭状态) */
sk->sk_state = TCP_CLOSE;
/* 将套接字与 socket 结构体关联 */
sk_set_socket(sk, sock);
/* 设置套接字的回调函数 */
//当套接字的状态发生变化时,这个回调函数被调用。例如,套接字从监听状态变为已连接状态,或者从已连接状态变为关闭状态。
sk->sk_state_change = sock_def_wakeup;
//当套接字接收队列中有数据可读时,这个回调函数被调用。它通知套接字数据已经准备好,可以被用户空间读取。
sk->sk_data_ready = sock_def_readable;
//当套接字的发送队列有足够的空间来接受新的数据时,这个回调函数被调用。它通知套接字发送缓冲区不再满,可以发送更多数据。
sk->sk_write_space = sock_def_write_space;
//当套接字遇到错误时,这个回调函数被调用。它负责向用户空间报告错误,例如连接重置、数据传输错误等。
sk->sk_error_report = sock_def_error_report;
//当套接字被销毁时,这个回调函数被调用。它负责执行清理操作,释放套接字占用的资源。
sk->sk_destruct = sock_def_destruct;
/* 设置套接字的接收和发送超时时间 */
sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
...
/* 设置套接字的时间戳 */
sk->sk_stamp = SK_DEFAULT_STAMP;
}
EXPORT_SYMBOL(sock_init_data);
2、内核IO和用户进程协作之阻塞方式
同步阻塞IO总体流程如下:
2.1 等待接收消息
recv函数通过strace命令跟踪,可以看到recv会执行recvform调用。
下面从源代码看看recvfrom是怎么把自己阻塞掉的。
cpp
SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
unsigned int, flags, struct sockaddr __user *, addr,
int __user *, addr_len)
{
...
err = import_single_range(READ, ubuf, size, &iov, &msg.msg_iter);
if (unlikely(err))
return err;
// 根据用户传入的fd找到socket对象
sock = sockfd_lookup_light(fd, &err, &fput_needed);
...
err = sock_recvmsg(sock, &msg, flags);
...
}
接下来调用顺序为:
sock_recvmsg==>sock_recvmsg_nosec==>inet_recvmsg==>tcp_recvmsg
cpp
int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)
{
int err = security_socket_recvmsg(sock, msg, msg_data_left(msg), flags);
return err ?: sock_recvmsg_nosec(sock, msg, flags);
}
static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
int flags)
{
return sock->ops->recvmsg(sock, msg, msg_data_left(msg), flags);
}
int inet_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
int flags)
{
struct sock *sk = sock->sk;
int addr_len = 0;
int err;
sock_rps_record_flow(sk);
err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
flags & ~MSG_DONTWAIT, &addr_len);
if (err >= 0)
msg->msg_namelen = addr_len;
return err;
}
cpp
int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
int flags, int *addr_len)
{
...
do {
...
//遍历接收队列接收数据
skb_queue_walk(&sk->sk_receive_queue, skb) {
...
//数据接收完成则返回
if (copied >= target && !sk->sk_backlog.tail)
break;
if (copied >= target) {
/* Do not sleep, just process backlog. */
release_sock(sk);
lock_sock(sk);
} else {
//没有收到足够的数据,启用sk_wait_data阻塞当前进程,等待数据到来的通知
sk_wait_data(sk, &timeo, last);
}
...
} while (len > 0);
}
EXPORT_SYMBOL(tcp_recvmsg);
这里可以看到,skb_queue_Walk在访问sock对象下的接收队列,如果没有收到数据或者收到的不够多,那么调用sk_wait_data将当前进程阻塞。
cpp
int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
{
//当前进程关联到所定义的等待队列项上,并设置唤醒回调函数
DEFINE_WAIT_FUNC(wait, woken_wake_function);
int rc;
//添加等待队列项到sock的等待队列中
add_wait_queue(sk_sleep(sk), &wait);
sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
//通过调用wait_woken让出CPU,然后进入睡眠
rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
remove_wait_queue(sk_sleep(sk), &wait);
return rc;
}
#define sk_wait_event(__sk, __timeo, __condition, __wait) \
({ int __rc; \
release_sock(__sk); \
__rc = __condition; \
if (!__rc) { \
*(__timeo) = wait_woken(__wait, \
TASK_INTERRUPTIBLE, \
*(__timeo)); \
} \
sched_annotate_sleep(); \
lock_sock(__sk); \
__rc = __condition; \
__rc; \
})
当内核收完数据产生就绪事件的时候,会通过回调查找socket等待队列项,进而可以找到回调函数和在等待该socket就绪事件的进程。
2.2 软中断模块
网络包从网卡后怎么接收再交给软中断处理的,这篇文章有描述:添加链接描述
下面从tcp_v4_rcv的源码开始看,总体接收流程如下:
软中断里收到数据之后,发现是TCP包就会执行tcp_v4_rcv函数。如果是ESTABLISH状态下的数据包,则最终会把数据解析出来放到对应socket的接收队列中,然后调用sk_data_ready来唤醒用户进程。
cpp
int tcp_v4_rcv(struct sk_buff *skb)
{
...
th = (const struct tcphdr *)skb->data; //获取tcp header
iph = ip_hdr(skb); //获取ip header
...
lookup:
//根据数据包header中的IP、端口信息查找到对应的socket
sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
th->dest, &refcounted);
if (!sk)
goto no_tcp_socket;
process:
if (sk->sk_state == TCP_TIME_WAIT)
goto do_time_wait;
if (sk->sk_state == TCP_NEW_SYN_RECV) {
struct request_sock *req = inet_reqsk(sk);
struct sock *nsk;
sk = req->rsk_listener;
if (unlikely(tcp_v4_inbound_md5_hash(sk, skb))) {
sk_drops_add(sk, skb);
reqsk_put(req);
goto discard_it;
}
if (unlikely(sk->sk_state != TCP_LISTEN)) {
inet_csk_reqsk_queue_drop_and_put(sk, req);
goto lookup;
}
/* We own a reference on the listener, increase it again
* as we might lose it too soon.
*/
sock_hold(sk);
refcounted = true;
nsk = tcp_check_req(sk, skb, req, false);
if (!nsk) {
reqsk_put(req);
goto discard_and_relse;
}
if (nsk == sk) {
reqsk_put(req);
} else if (tcp_child_process(sk, nsk, skb)) {
tcp_v4_send_reset(nsk, skb);
goto discard_and_relse;
} else {
sock_put(sk);
return 0;
}
}
if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
__NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
goto discard_and_relse;
}
if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
goto discard_and_relse;
if (tcp_v4_inbound_md5_hash(sk, skb))
goto discard_and_relse;
nf_reset(skb);
if (tcp_filter(sk, skb))
goto discard_and_relse;
th = (const struct tcphdr *)skb->data;
iph = ip_hdr(skb);
skb->dev = NULL;
if (sk->sk_state == TCP_LISTEN) {
ret = tcp_v4_do_rcv(sk, skb);
goto put_and_return;
}
//socket未被用户锁定
if (!sock_owned_by_user(sk)) {
if (!tcp_prequeue(sk, skb))
ret = tcp_v4_do_rcv(sk, skb);
} else if (tcp_add_backlog(sk, skb)) {
goto discard_and_relse;
}
}
在tcp_v4_do_rcv中,首先找到对应skb对应的socket,然后进入tcp_v4_do_rcv。
cpp
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
struct sock *rsk;
if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
struct dst_entry *dst = sk->sk_rx_dst;
sock_rps_save_rxhash(sk, skb);
sk_mark_napi_id(sk, skb);
if (dst) {
if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
!dst->ops->check(dst, 0)) {
dst_release(dst);
sk->sk_rx_dst = NULL;
}
}
//执行连接状态下的数据处理
tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
return 0;
}
//其他非ESTABLISH状态的数据包处理
...
}
在tcp_v4_do_rcv中会调用tcp_rcv_established,在tcp_rcv_established中会调用tcp_queue_rcv把数据添加到接收队列末尾,然后调用sock的sk_data_ready函数指针,这个指针在sock初始化的时候已经被设置成了sock_def_readable,所以会调用到sock_def_readable。
cpp
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
const struct tcphdr *th, unsigned int len)
{
struct tcp_sock *tp = tcp_sk(sk); // 获取 TCP 套接字的特定结构体
skb_mstamp_get(&tp->tcp_mstamp); // 获取当前时间戳
if (unlikely(!sk->sk_rx_dst)) // 检查接收目的地是否已设置
inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb); // 设置接收目的地
/*
* 头部预测。
* 代码大致遵循 Van Jacobson 的 "30 instruction TCP receive"。
*/
tp->rx_opt.saw_tstamp = 0; // 初始化接收选项
/* 检查 TCP 头部的有效性 */
if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
int tcp_header_len = tp->tcp_header_len;
if (len <= tcp_header_len) {
...
if (!eaten) {
...
/* 大量数据传输:接收方 */
eaten = tcp_queue_rcv(sk, skb, tcp_header_len, &fragstolen); // 将数据包排入接收队列
}
tcp_event_data_recv(sk, skb); // 触发数据接收事件
if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {
/* 处理 ACK */
tcp_ack(sk, skb, FLAG_DATA);
tcp_data_snd_check(sk); // 检查发送数据
if (!inet_csk_ack_scheduled(sk))
goto no_ack;
}
__tcp_ack_snd_check(sk, 0); // 检查 ACK 发送
no_ack:
if (eaten)
kfree_skb_partial(skb, fragstolen); // 释放部分数据包
sk->sk_data_ready(sk); // 通知套接字有数据可读
return;
}
}
...
}
EXPORT_SYMBOL(tcp_rcv_established);
cpp
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
bool *fragstolen)
{
int eaten;
struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);
__skb_pull(skb, hdrlen);
eaten = (tail &&
tcp_try_coalesce(sk, tail, skb, fragstolen)) ? 1 : 0;
tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
//将接收到的数据添加到尾部
if (!eaten) {
__skb_queue_tail(&sk->sk_receive_queue, skb);
skb_set_owner_r(skb, sk);
}
return eaten;
}
cpp
static void sock_def_readable(struct sock *sk)
{
struct socket_wq *wq;
rcu_read_lock();
wq = rcu_dereference(sk->sk_wq);
if (skwq_has_sleeper(wq))
//唤醒等待队列的进程
wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
POLLRDNORM | POLLRDBAND);
sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
rcu_read_unlock();
}
#define wake_up_interruptible_sync_poll(x, m) \
__wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
//nr_exclusive被宏定义成了1,是为了防止惊群
void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, void *key)
{
unsigned long flags;
int wake_flags = 1; /* XXX WF_SYNC */
if (unlikely(!q))
return;
if (unlikely(nr_exclusive != 1))
wake_flags = 0;
spin_lock_irqsave(&q->lock, flags);
__wake_up_common(q, mode, nr_exclusive, wake_flags, key);
spin_unlock_irqrestore(&q->lock, flags);
}
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
wait_queue_t *curr, *next;
list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
unsigned flags = curr->flags;
//调用进程加入等待队列时注册的回调函数
if (curr->func(curr, mode, wake_flags, key) &&
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
}
}
__wake_up_common实现唤醒,该函数调用的传入参数nr_exclusive写死了为1,这里是指即使有多个进程都阻塞在同一个socket上,也只唤醒一个进程。其作用是为了避免"惊群"。在recv注册等待队列项的时候,内核把curr->func设置成了woken_wake_function;在woken_wake_function中调用了woken_wake_function,最终调用到了try_to_wake_up,调用try_to_wake_up传入的参数curr->private就是当时因为等待而被阻塞的进程任务。当这个函数执行完的时候,在socket上等待而被阻塞的进程就被推入可运行队列了。
cpp
int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
wait->flags |= WQ_FLAG_WOKEN;
return default_wake_function(wait, mode, sync, key);
}
int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
void *key)
{
return try_to_wake_up(curr->private, mode, wake_flags);
}
同步阻塞整体流程图如下:
文章内容参考:《深入理解Linux网络》
Linux版本用的是4.12,书中用的是3.10