scoket系统调用主要完成socket的创建，必要字段的初始化，关联传输控制块，绑定文件等任务，完成返回socket绑定的文件描述符；
1 /** 2 * socket函数调用关系 3 * sys_socket 4 * |-->sock_create 5 * | |-->__sock_create 6 * | |-->inet_create 7 * |-->sock_map_fd 8 */
1 SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) 2 { 3 int retval; 4 struct socket *sock; 5 int flags; 6 7 /* Check the SOCK_* constants for consistency. */ 8 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 9 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 10 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 11 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 12 13 /* 取得标志 */ 14 flags = type & ~SOCK_TYPE_MASK; 15 16 /* 除此标记之外还有标记，错误 */ 17 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 18 return -EINVAL; 19 20 /* 取得类型 */ 21 type &= SOCK_TYPE_MASK; 22 23 24 /* 标记以O_NONBLOCK为准 */ 25 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 26 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 27 28 /* 创建socket */ 29 retval = sock_create(family, type, protocol, &sock); 30 if (retval < 0) 31 goto out; 32 33 /* 创建socket文件并绑定描述符 */ 34 retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 35 if (retval < 0) 36 goto out_release; 37 38 out: 39 /* It may be already another descriptor 8) Not kernel problem. */ 40 return retval; 41 42 out_release: 43 sock_release(sock); 44 return retval; 45 }
因为sock_create调用层次较多，放到下面来分析，此处先看下sock_map_fd函数，该函数负责分配文件，并与socket进行绑定；
1 /* 套接口与文件描述符绑定 */ 2 static int sock_map_fd(struct socket *sock, int flags) 3 { 4 struct file *newfile; 5 /* 获取未使用的文件描述符 */ 6 int fd = get_unused_fd_flags(flags); 7 if (unlikely(fd < 0)) 8 return fd; 9 10 /* 分配socket文件 */ 11 newfile = sock_alloc_file(sock, flags, NULL); 12 if (likely(!IS_ERR(newfile))) { 13 /* fd和文件进行绑定 */ 14 fd_install(fd, newfile); 15 return fd; 16 } 17 18 /* 释放fd */ 19 put_unused_fd(fd); 20 return PTR_ERR(newfile); 21 }
下面来分析sock_create流程，其主要工作为创建socket，并进行必要的初始化；
1 int sock_create(int family, int type, int protocol, struct socket **res) 2 { 3 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 4 }
__socket_create函数负责必要的检查项，创建socket，必要的初始化，之后调用对应协议族的pf->create函数来创建传输控制块，并且与socket进行关联；
1 /* 创建socket */ 2 int __sock_create(struct net *net, int family, int type, int protocol, 3 struct socket **res, int kern) 4 { 5 int err; 6 struct socket *sock; 7 const struct net_proto_family *pf; 8 9 /* 10 * Check protocol is in range 11 */ 12 /* 检查协议族 */ 13 if (family < 0 || family >= NPROTO) 14 return -EAFNOSUPPORT; 15 16 /* 检查类型 */ 17 if (type < 0 || type >= SOCK_MAX) 18 return -EINVAL; 19 20 /* Compatibility. 21 22 This uglymoron is moved from INET layer to here to avoid 23 deadlock in module load. 24 */ 25 /* ipv4协议族的packet已经废除，检测到，则替换成packet协议族 */ 26 if (family == PF_INET && type == SOCK_PACKET) { 27 pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET) ", 28 current->comm); 29 family = PF_PACKET; 30 } 31 32 /* 安全模块检查套接口 */ 33 err = security_socket_create(family, type, protocol, kern); 34 if (err) 35 return err; 36 37 /* 38 * Allocate the socket and allow the family to set things up. if 39 * the protocol is 0, the family is instructed to select an appropriate 40 * default. 41 */ 42 /* 分配socket，内部和inode已经绑定 */ 43 sock = sock_alloc(); 44 if (!sock) { 45 net_warn_ratelimited("socket: no more sockets "); 46 return -ENFILE; /* Not exactly a match, but its the 47 closest posix thing */ 48 } 49 50 /* 设定类型 */ 51 sock->type = type; 52 53 #ifdef CONFIG_MODULES 54 /* Attempt to load a protocol module if the find failed. 55 * 56 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 57 * requested real, full-featured networking support upon configuration. 58 * Otherwise module support will break! 59 */ 60 if (rcu_access_pointer(net_families[family]) == NULL) 61 request_module("net-pf-%d", family); 62 #endif 63 64 rcu_read_lock(); 65 /* 找到协议族 */ 66 pf = rcu_dereference(net_families[family]); 67 err = -EAFNOSUPPORT; 68 if (!pf) 69 goto out_release; 70 71 /* 72 * We will call the ->create function, that possibly is in a loadable 73 * module, so we have to bump that loadable module refcnt first. 74 */ 75 /* 增加模块的引用计数 */ 76 if (!try_module_get(pf->owner)) 77 goto out_release; 78 79 /* Now protected by module ref count */ 80 rcu_read_unlock(); 81 82 /* 调用协议族的创建函数 */ 83 err = pf->create(net, sock, protocol, kern); 84 if (err < 0) 85 goto out_module_put; 86 87 /* 88 * Now to bump the refcnt of the [loadable] module that owns this 89 * socket at sock_release time we decrement its refcnt. 90 */ 91 if (!try_module_get(sock->ops->owner)) 92 goto out_module_busy; 93 94 /* 95 * Now that we're done with the ->create function, the [loadable] 96 * module can have its refcnt decremented 97 */ 98 module_put(pf->owner); 99 err = security_socket_post_create(sock, family, type, protocol, kern); 100 if (err) 101 goto out_sock_release; 102 *res = sock; 103 104 return 0; 105 106 out_module_busy: 107 err = -EAFNOSUPPORT; 108 out_module_put: 109 sock->ops = NULL; 110 module_put(pf->owner); 111 out_sock_release: 112 sock_release(sock); 113 return err; 114 115 out_release: 116 rcu_read_unlock(); 117 goto out_sock_release; 118 } 119 EXPORT_SYMBOL(__sock_create);
对于PF_INET协议族来讲，上述的pf->create函数将调用inet_create函数；
1 static const struct net_proto_family inet_family_ops = { 2 .family = PF_INET, 3 .create = inet_create, 4 .owner = THIS_MODULE, 5 };
inet_create函数负责创建传输控制块，并且将socket与传输控制块进行关联；
1 /* 2 * Create an inet socket. 3 */ 4 5 /* 创建与该接口对应的传输控制块并关联 */ 6 static int inet_create(struct net *net, struct socket *sock, int protocol, 7 int kern) 8 { 9 struct sock *sk; 10 struct inet_protosw *answer; 11 struct inet_sock *inet; 12 struct proto *answer_prot; 13 unsigned char answer_flags; 14 int try_loading_module = 0; 15 int err; 16 17 /* 检查协议 */ 18 if (protocol < 0 || protocol >= IPPROTO_MAX) 19 return -EINVAL; 20 21 /* 设置接口的状态为未连接 */ 22 sock->state = SS_UNCONNECTED; 23 24 /* Look for the requested type/protocol pair. */ 25 lookup_protocol: 26 err = -ESOCKTNOSUPPORT; 27 rcu_read_lock(); 28 list_for_each_entry_rcu(answer, &inetsw[sock->type], list) { 29 30 err = 0; 31 /* Check the non-wild match. */ 32 /* 匹配协议成功 */ 33 if (protocol == answer->protocol) { 34 /* 传入为某指定协议，成功*/ 35 if (protocol != IPPROTO_IP) 36 break; 37 38 /* 未指定协议，继续查找 */ 39 40 } 41 /* 未指定协议或者未匹配成功的分支 */ 42 else { 43 /* Check for the two wild cases. */ 44 /* 如果传入为未指定协议 */ 45 if (IPPROTO_IP == protocol) { 46 /* 则指定为当前协议，成功 */ 47 protocol = answer->protocol; 48 break; 49 } 50 51 /* 指定了传入协议，但是均未匹配成功 */ 52 53 /* 当前正在匹配的协议通用协议，则使用之 */ 54 if (IPPROTO_IP == answer->protocol) 55 break; 56 } 57 58 /* 循环查找结束了，还未找到 */ 59 /* 传入了某指定协议，未找到匹配，并且没有通用协议 */ 60 err = -EPROTONOSUPPORT; 61 } 62 63 /* 64 未找到对应inet_protosw实例 65 加载对应的协议模块，重新查找 66 */ 67 if (unlikely(err)) { 68 /* 尝试加载的模块不超过2次 */ 69 if (try_loading_module < 2) { 70 rcu_read_unlock(); 71 /* 72 * Be more specific, e.g. net-pf-2-proto-132-type-1 73 * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM) 74 */ 75 /* 第一次，加载指定协议和类型的模块 */ 76 if (++try_loading_module == 1) 77 request_module("net-pf-%d-proto-%d-type-%d", 78 PF_INET, protocol, sock->type); 79 /* 80 * Fall back to generic, e.g. net-pf-2-proto-132 81 * (net-pf-PF_INET-proto-IPPROTO_SCTP) 82 */ 83 /* 第二次，加载只指定协议的模块 */ 84 else 85 request_module("net-pf-%d-proto-%d", 86 PF_INET, protocol); 87 goto lookup_protocol; 88 } 89 /* 超过2次，则查找失败 */ 90 else 91 goto out_rcu_unlock; 92 } 93 94 err = -EPERM; 95 96 /* 判断是否允许创建sock-raw套接口 */ 97 if (sock->type == SOCK_RAW && !kern && 98 !ns_capable(net->user_ns, CAP_NET_RAW)) 99 goto out_rcu_unlock; 100 101 /* 设置套接口操作 */ 102 sock->ops = answer->ops; 103 /* 临时存储协议的操作和标志 */ 104 answer_prot = answer->prot; 105 answer_flags = answer->flags; 106 rcu_read_unlock(); 107 108 WARN_ON(!answer_prot->slab); 109 110 err = -ENOBUFS; 111 /* 分配传输控制块 */ 112 sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern); 113 if (!sk) 114 goto out; 115 116 err = 0; 117 /* 设置重用地址和端口标记 */ 118 if (INET_PROTOSW_REUSE & answer_flags) 119 sk->sk_reuse = SK_CAN_REUSE; 120 121 inet = inet_sk(sk); 122 123 /* 设置是否为面向连接的控制块 */ 124 inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0; 125 126 inet->nodefrag = 0; 127 128 /* 如果类型是原始套接字 */ 129 if (SOCK_RAW == sock->type) { 130 /* 设置本地端口为协议号 */ 131 inet->inet_num = protocol; 132 133 /* 协议为ipproto_raw */ 134 if (IPPROTO_RAW == protocol) 135 /* 标记需要自己构建ip首部 */ 136 inet->hdrincl = 1; 137 } 138 139 /* 设置是否支持pmtu */ 140 if (net->ipv4.sysctl_ip_no_pmtu_disc) 141 inet->pmtudisc = IP_PMTUDISC_DONT; 142 else 143 inet->pmtudisc = IP_PMTUDISC_WANT; 144 145 /* 出事连接控制块 */ 146 inet->inet_id = 0; 147 148 /* 连接控制块的初始化 */ 149 sock_init_data(sock, sk); 150 151 sk->sk_destruct = inet_sock_destruct; 152 sk->sk_protocol = protocol; 153 sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv; 154 155 inet->uc_ttl = -1; 156 inet->mc_loop = 1; 157 inet->mc_ttl = 1; 158 inet->mc_all = 1; 159 inet->mc_index = 0; 160 inet->mc_list = NULL; 161 inet->rcv_tos = 0; 162 163 sk_refcnt_debug_inc(sk); 164 165 /* 设置了本地端口 */ 166 if (inet->inet_num) { 167 /* It assumes that any protocol which allows 168 * the user to assign a number at socket 169 * creation time automatically 170 * shares. 171 */ 172 173 /* 设置网络序的源端口 */ 174 inet->inet_sport = htons(inet->inet_num); 175 /* Add to protocol hash chains. */ 176 /* 加入到hash */ 177 err = sk->sk_prot->hash(sk); 178 if (err) { 179 sk_common_release(sk); 180 goto out; 181 } 182 } 183 184 /* 如果有init则调用init初始化 */ 185 if (sk->sk_prot->init) { 186 err = sk->sk_prot->init(sk); 187 if (err) { 188 sk_common_release(sk); 189 goto out; 190 } 191 } 192 193 if (!kern) { 194 err = BPF_CGROUP_RUN_PROG_INET_SOCK(sk); 195 if (err) { 196 sk_common_release(sk); 197 goto out; 198 } 199 } 200 out: 201 return err; 202 out_rcu_unlock: 203 rcu_read_unlock(); 204 goto out; 205 }