linux下的网络编程离不开socket，中文被翻译为套接字。任何网络通信都必须先建立socket，再通过socket给对方收发数据！数据接受的demo代码如下：
#include <string.h> #include <sys/socket.h> #include <sys/types.h> #define SET_PORT 3490 int main(void) { int sockfd, new_fd; struct sockaddr_in my_addr; struct sockaddr_in their_addr; int sin_size; sockfd = socket(PF_INET, SOCK_STREAM, 0); my_addr.sin_family = AF_INET; my_addr.sin_port = htons(_INT_PORT); my_addr.sin_addr.s_addr = INADDR_ANY; bzero(&(my_addr.sin_zero),sizeof(my_addr.sin_zero)); bind(sockfd, (struct sockaddr *)&my_addr,sizeof(struct sockaddr));// 绑定套接字 listen(sockfd, 10); // 监听套接字 sin_size = sizeof(struct sockaddr_in); new_fd = accept(sockfd, &their_addr, &sin_size); // 接收套接字 }
可以看出，需要先调用socket函数建立socket，再绑定套接字，最后监听和接受数据。 这个socket到底是啥？linux在内核中又是怎么使用的了？
1、（1）socket是个结构体，字段不多，但是嵌套了其他结构体，各种嵌套的关系标识如下：
- proto_ops：用户层调用的各种接口就是在这里注册的（篇幅有限，截图的字段不全）
- wq：等待该socket的进程队列和异步通知队列；换句话说：同一个socket可能有多个进程都在等待使用！
- sock：应该是socket结构体最核心的嵌套结构体了（篇幅有限，截图的字段不全）！
（2）socket结构体有了，接下来就是创建和初始化了！linux内核创建socket的函数是__sock_create，核心代码如下：
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; ......... /* * Allocate the socket and allow the family to set things up. if * the protocol is 0, the family is instructed to select an appropriate * default. 本质：创建socket结构体，存放在inode，通过superblock统一检索和管理 */ sock = sock_alloc(); ......... /*socket就是在这里创建的,实际调用的是inet_create af_inet.c文件中： static const struct net_proto_family inet_family_ops = { .family = PF_INET, .create = inet_create, .owner = THIS_MODULE, };*/ err = pf->create(net, sock, protocol, kern); .................. }
创建socket的核心函数就2个:sock_alloc，还有pf->create！先看第一个sock_alloc，代码如下：
/** * sock_alloc - allocate a socket * * Allocate a new inode and socket object. The two are bound together * and initialised. The socket is then returned. If we are out of inodes * NULL is returned. 明明是申请socket，底层却分配inode，这是为啥了？ 1、socket也需要管理，放在inode后通过super_bloc统一检索和管理 2、socket的属性字段自然也存放在inode节点了 3、符合万物皆文件的理念 */ struct socket *sock_alloc(void) { struct inode *inode; struct socket *sock; //从超级块里分配一个inode inode = new_inode_pseudo(sock_mnt->mnt_sb); if (!inode) return NULL; /*把inode和socket绑定在一起，通过inode寻址socket，便于管理*/ sock = SOCKET_I(inode); kmemcheck_annotate_bitfield(sock, type);//标记shadow memory来表示这块内存已经使用了 inode->i_ino = get_next_ino(); inode->i_mode = S_IFSOCK | S_IRWXUGO; inode->i_uid = current_fsuid(); inode->i_gid = current_fsgid(); inode->i_op = &sockfs_inode_ops; this_cpu_add(sockets_in_use, 1); return sock; }
本质上就是分配一个inode，然后和socket结构体绑定，通过inode寻址socket结构体！socket结构体有了，接下来就是在socket内部嵌套的sock结构体了！其生成和初始化的工作都是在inet_create内部完成的，代码如下：
static int inet_create(struct net *net, struct socket *sock, int protocol, int kern) { struct sock *sk; struct inet_protosw *answer; struct inet_sock *inet; struct proto *answer_prot; unsigned char answer_flags; int try_loading_module = 0; int err; if (protocol < 0 || protocol >= IPPROTO_MAX) return -EINVAL; sock->state = SS_UNCONNECTED;//初始化状态当然设置成未连接了 /* Look for the requested type/protocol pair. */ lookup_protocol: err = -ESOCKTNOSUPPORT; rcu_read_lock(); list_for_each_entry_rcu(answer, &inetsw[sock->type], list) { err = 0; /* Check the non-wild match. */ if (protocol == answer->protocol) { if (protocol != IPPROTO_IP) break; } else { /* Check for the two wild cases. */ 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(); /* * Be more specific, e.g. net-pf-2-proto-132-type-1 * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM) */ if (++try_loading_module == 1) request_module("net-pf-%d-proto-%d-type-%d", PF_INET, protocol, sock->type); /* * Fall back to generic, e.g. net-pf-2-proto-132 * (net-pf-PF_INET-proto-IPPROTO_SCTP) */ else request_module("net-pf-%d-proto-%d", PF_INET, protocol); goto lookup_protocol; } else goto out_rcu_unlock; } err = -EPERM; if (sock->type == SOCK_RAW && !kern && !ns_capable(net->user_ns, CAP_NET_RAW)) goto out_rcu_unlock; sock->ops = answer->ops; answer_prot = answer->prot; answer_flags = answer->flags; rcu_read_unlock(); WARN_ON(!answer_prot->slab); err = -ENOBUFS; /*从cpu缓存或堆内存分配空间存储sock实例，并初始化*/ 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; /* 1、强制转换成inet_sock类型，便于继续初始化； 2、inet和sk指针并未改变，指向的是同一块内存地址，两个指针可以同时使用 */ inet = inet_sk(sk); inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0; 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; /* 1、初始化sk_buff的读、写、错误队列 2、关联socket和sock的实例 3、定义sock的回调函数 4、初始化其他sock字段 */ sock_init_data(sock, sk); sk->sk_destruct = inet_sock_destruct;//析构时的回调函数 sk->sk_protocol = protocol;//协议类型 sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv; //sk和inet交替使用来初始化 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);//引用计数+1 if (inet->inet_num) { /* It assumes that any protocol which allows * the user to assign a number at socket * creation time automatically * shares. */ inet->inet_sport = htons(inet->inet_num); /* Add to protocol hash chains. */ 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); } out: return err; out_rcu_unlock: rcu_read_unlock(); goto out; }
整个逻辑并不复杂，先是调用sk_alloc函数生成sock实例，再调用sock_init_data初始化sock实力，并和socket实例关联，所以我个人认为sock_init_data是最核心的函数，如下:
/* 1、初始化sk_buff的读、写、错误队列 2、关联socket和sock的实例 3、定义sock的回调函数 4、初始化其他sock字段 */ void sock_init_data(struct socket *sock, struct sock *sk) { /*初始化sk_buff的读写、错误队列*/ skb_queue_head_init(&sk->sk_receive_queue); skb_queue_head_init(&sk->sk_write_queue); skb_queue_head_init(&sk->sk_error_queue); sk->sk_send_head = NULL; //初始化定时器 init_timer(&sk->sk_timer); sk->sk_allocation = GFP_KERNEL; sk->sk_rcvbuf = sysctl_rmem_default; sk->sk_sndbuf = sysctl_wmem_default; sk->sk_state = TCP_CLOSE; //这里终于把socket和sock实例关联起来了 sk_set_socket(sk, sock); sock_set_flag(sk, SOCK_ZAPPED); if (sock) { sk->sk_type = sock->type; sk->sk_wq = sock->wq; sock->sk = sk; } else sk->sk_wq = NULL; rwlock_init(&sk->sk_callback_lock); lockdep_set_class_and_name(&sk->sk_callback_lock, af_callback_keys + sk->sk_family, af_family_clock_key_strings[sk->sk_family]); 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;//发生io错误时的回调函数 sk->sk_destruct = sock_def_destruct; sk->sk_frag.page = NULL; sk->sk_frag.offset = 0; sk->sk_peek_off = -1; sk->sk_peer_pid = NULL; sk->sk_peer_cred = NULL; sk->sk_write_pending = 0; sk->sk_rcvlowat = 1; sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT; sk->sk_stamp = ktime_set(-1L, 0); #ifdef CONFIG_NET_RX_BUSY_POLL sk->sk_napi_id = 0; sk->sk_ll_usec = sysctl_net_busy_read; #endif sk->sk_max_pacing_rate = ~0U; sk->sk_pacing_rate = ~0U; sk->sk_incoming_cpu = -1; /* * Before updating sk_refcnt, we must commit prior changes to memory * (Documentation/RCU/rculist_nulls.txt for details) */ smp_wmb(); atomic_set(&sk->sk_refcnt, 1); atomic_set(&sk->sk_drops, 0); }
上面有几个回调函数，其实实现的逻辑的代码结构基本是一样的：
/* * Default Socket Callbacks 当sock的状态发生改变时，会调用此函数来进行处理 */ static void sock_def_wakeup(struct sock *sk) { struct socket_wq *wq; rcu_read_lock(); wq = rcu_dereference(sk->sk_wq); if (skwq_has_sleeper(wq))//有进程阻塞在这个socket //唤醒所有在等待这个socket的进程，核心就是执行进程唤醒的回调函数 wake_up_interruptible_all(&wq->wait); rcu_read_unlock(); } /*sock有输入数据可读时，会调用此函数来处理*/ 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); /* 异步通知队列的处理。 * 检查应用程序是否通过recv()类调用来等待接收数据，如果没有就发送SIGIO信号， * 告知它有数据可读。 * how为函数的处理方式，band为用来告知的IO类型。 */ sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN); rcu_read_unlock(); }
当有可读数据的时候，肯定第一时间通知相应的进程来读取数据，核心是通过sk_wake_async函数实现的；而sk_wake_async最终调用了kill_fasync_rcu来给排队等待的队列发出SIGIO信号，通知这些队列中的进程来取数据了！异步的好处在这里就凸显了：进程不用在这里空转等数据，而是可以释放cpu去执行其他进程的代码；等socket有数据后再通过类似中断的形式通知等待的进程来取数据了！
/* * rcu_read_lock() is held 函数名有kill，但实际是向队列的进程发送SIGIO信号 */ static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band) { while (fa) { struct fown_struct *fown; unsigned long flags; if (fa->magic != FASYNC_MAGIC) { printk(KERN_ERR "kill_fasync: bad magic number in " "fasync_struct!\n"); return; } spin_lock_irqsave(&fa->fa_lock, flags); if (fa->fa_file) { fown = &fa->fa_file->f_owner; /* Don't send SIGURG to processes which have not set a queued signum: SIGURG has its own default signalling mechanism. */ if (!(sig == SIGURG && fown->signum == 0)) send_sigio(fown, fa->fa_fd, band); } spin_unlock_irqrestore(&fa->fa_lock, flags); fa = rcu_dereference(fa->fa_next); } }