【Linux 内核网络协议栈源码剖析】socket 函数剖析


http://blog.csdn.net/wenqian1991/article/details/46707521


深度剖析网络协议栈中的 socket 函数，可以说是把前面介绍的串联起来，将网络协议栈各层关联起来。

                      

1、应用层——socket 函数

 为了执行网络I/O，一个进程必须做的第一件事就是调用socket函数，指定期望的通信协议类型。该函数只是作为一个简单的接口函数供用户调用，调用该函数后将进入内核栈进行系统调用sock_socket 函数。

[cpp] view plain copy print?
  1. #include <sys/socket.h>  
  2. int socket(int family, int type, int protocol);  
  3.                             /*返回：非负描述字——成功， -1——出错 
  4. 其中family参数指明协议族，type参数指明套接口类型，后面protocol通常设为0，以选择所给定family 和 type组合的系统缺省值*/  
2、BSD Socket 层——sock_socket 函数

从应用层进入该函数是通过一个共同的入口函数 sys_socket

[cpp] view plain copy print?
  1. /* 
  2.  *  System call vectors. Since I (RIB) want to rewrite sockets as streams, 
  3.  *  we have this level of indirection. Not a lot of overhead, since more of 
  4.  *  the work is done via read/write/select directly. 
  5.  * 
  6.  *  I'm now expanding this up to a higher level to separate the assorted 
  7.  *  kernel/user space manipulations and global assumptions from the protocol 
  8.  *  layers proper - AC. 
  9.  */  
  10. //本函数是网络栈专用操作函数集的总入口函数，主要是将请求分配，调用具体的底层函数进行处理  
  11. asmlinkage int sys_socketcall(int call, unsigned long *args)  
  12. {  
  13.     int er;  
  14.     switch(call)   
  15.     {  
  16.         case SYS_SOCKET://socket函数  
  17.             er=verify_area(VERIFY_READ, args, 3 * sizeof(long));  
  18.             if(er)  
  19.                 return er;  
  20.             return(sock_socket(get_fs_long(args+0),  
  21.                 get_fs_long(args+1),//返回地址上的值  
  22.                 get_fs_long(args+2)));//调用sock_socket函数  
  23.                   ……  
  24. }  
下面就是sock_socket 函数主体
[cpp] view plain copy print?
  1. /* 
  2.  *  系统调用，创建套接字socket。涉及到sock结构的创建. 
  3.  */  
  4.   
  5. static int sock_socket(int family, int type, int protocol)  
  6. {  
  7.     int i, fd;  
  8.     struct socket *sock;  
  9.     struct proto_ops *ops;  
  10.   
  11.     /* 匹配应用程序调用socket()函数时指定的协议 */  
  12.     for (i = 0; i < NPROTO; ++i)   
  13.     {  
  14.         if (pops[i] == NULL) continue;  
  15.         if (pops[i]->family == family) //设置域  
  16.             break;  
  17.     }  
  18.     //没有匹配的协议，则出错退出  
  19.     if (i == NPROTO)   
  20.     {  
  21.         return -EINVAL;  
  22.     }  
  23.     //根据family输入参数决定域操作函数集用于ops字段的赋值  
  24.     //操作函数集是跟域相关的，不同的域对应不同的操作函数集  
  25.     ops = pops[i];  
  26.   
  27. /* 
  28.  *  Check that this is a type that we know how to manipulate and 
  29.  *  the protocol makes sense here. The family can still reject the 
  30.  *  protocol later. 
  31.  */  
  32.   //套接字类型检查  
  33.     if ((type != SOCK_STREAM && type != SOCK_DGRAM &&  
  34.         type != SOCK_SEQPACKET && type != SOCK_RAW &&  
  35.         type != SOCK_PACKET) || protocol < 0)  
  36.             return(-EINVAL);  
  37.   
  38. /* 
  39.  *  Allocate the socket and allow the family to set things up. if 
  40.  *  the protocol is 0, the family is instructed to select an appropriate 
  41.  *  default. 
  42.  */  
  43.     //分配socket套接字结构  
  44.     if (!(sock = sock_alloc()))   
  45.     {  
  46.         printk("NET: sock_socket: no more sockets\n");  
  47.         return(-ENOSR); /* Was: EAGAIN, but we are out of 
  48.                    system resources! */  
  49.     }  
  50.     //指定对应类型，协议，以及操作函数集  
  51.     sock->type = type;  
  52.     sock->ops = ops;  
  53.     //分配下层sock结构，sock结构是比socket结构更底层的表示一个套接字的结构  
  54.     //前面博文有说明:http://blog.csdn.net/wenqian1991/article/details/21740945  
  55.     //socket是通用的套接字结构体，而sock与具体使用的协议相关  
  56.     if ((i = sock->ops->create(sock, protocol)) < 0) //这里调用下层函数 create  
  57.     {  
  58.         sock_release(sock);//出错回滚销毁处理  
  59.         return(i);  
  60.     }  
  61.     //分配一个文件描述符并在后面返回给应用层序作为以后的操作句柄  
  62.     if ((fd = get_fd(SOCK_INODE(sock))) < 0)   
  63.     {  
  64.         sock_release(sock);  
  65.         return(-EINVAL);  
  66.     }  
  67.   
  68.     return(fd);//这个就是我们应用系统使用的套接字描述符  
  69. }  
该要介绍的注释里，已经说明白了，可以看到，该函数又将调用下一层函数 create。（网络栈就是这样，上层调用下层函数）

sock_socket 函数内部还调用了一个函数 sock_alloc()，该函数主要是分配一个 socket 套接字结构（实际上找到一个空闲的inode结构，socket结构已经包含在inode结构中）

[cpp] view plain copy print?
  1. /* 
  2.  *  分配一个socket结构 
  3.  */  
  4. struct socket *sock_alloc(void)  
  5. {  
  6.     struct inode * inode;  
  7.     struct socket * sock;  
  8.   
  9.     inode = get_empty_inode();//分配一个inode对象  
  10.     if (!inode)  
  11.         return NULL;  
  12.     //获得的inode结构的初始化  
  13.     inode->i_mode = S_IFSOCK;  
  14.     inode->i_sock = 1;  
  15.     inode->i_uid = current->uid;  
  16.     inode->i_gid = current->gid;  
  17.     //可以看出socket结构体的实体空间，就已经存在了inode结构中的union类型中，  
  18.     //所以无需单独的开辟空间分配一个socket 结构  
  19.     sock = &inode->u.socket_i;//这里把inode的union结构中的socket变量地址传给sock  
  20.     sock->state = SS_UNCONNECTED;  
  21.     sock->flags = 0;  
  22.     sock->ops = NULL;  
  23.     sock->data = NULL;  
  24.     sock->conn = NULL;  
  25.     sock->iconn = NULL;  
  26.     sock->next = NULL;  
  27.     sock->wait = &inode->i_wait;  
  28.     sock->inode = inode;//回绑  
  29.     sock->fasync_list = NULL;  
  30.     sockets_in_use++;//系统当前使用的套接字数量加1  
  31.     return sock;  
  32. }  

3、INET Socket 层——inet_create 函数

[cpp] view plain copy print?
  1. /* 
  2.  *  Create an inet socket. 
  3.  * 
  4.  *  FIXME: Gcc would generate much better code if we set the parameters 
  5.  *  up in in-memory structure order. Gcc68K even more so 
  6.  */  
  7.  //该函数被上层sock_socket函数调用，用于创建一个socket套接字对应的sock结构并对其进行初始化  
  8.  //socket是通用结构，sock是具体到某种协议的结构  
  9.  //代码是一大串，功能就是建立套接字对应的sock结构并对其进行初始化  
  10. static int inet_create(struct socket *sock, int protocol)  
  11. {  
  12.     struct sock *sk;  
  13.     struct proto *prot;  
  14.     int err;  
  15.     //分配一个sock结构，内存分配一个实体  
  16.     sk = (struct sock *) kmalloc(sizeof(*sk), GFP_KERNEL);  
  17.     if (sk == NULL)   
  18.         return(-ENOBUFS);  
  19.     sk->num = 0;//本地端口号  
  20.     sk->reuse = 0;  
  21.     //根据类型进行相关字段的赋值  
  22.     //关于哪种类型与协议的对应关系，请参考<UNP 卷1>，有些类型就只能和某种协议对应  
  23.     switch(sock->type)   
  24.     {  
  25.         case SOCK_STREAM:  
  26.         case SOCK_SEQPACKET:  
  27.             if (protocol && protocol != IPPROTO_TCP)   
  28.             {  
  29.                 kfree_s((void *)sk, sizeof(*sk));  
  30.                 return(-EPROTONOSUPPORT);  
  31.             }  
  32.             protocol = IPPROTO_TCP;//tcp协议  
  33.             sk->no_check = TCP_NO_CHECK;  
  34.             //这个prot变量表明了套接字使用的是何种协议  
  35.             //然后使用的则是对应协议的操作函数  
  36.             prot = &tcp_prot;  
  37.             break;  
  38.   
  39.         case SOCK_DGRAM:  
  40.             if (protocol && protocol != IPPROTO_UDP)   
  41.             {  
  42.                 kfree_s((void *)sk, sizeof(*sk));  
  43.                 return(-EPROTONOSUPPORT);  
  44.             }  
  45.             protocol = IPPROTO_UDP;//udp协议  
  46.             sk->no_check = UDP_NO_CHECK;//不使用校验  
  47.             prot=&udp_prot;  
  48.             break;  
  49.         
  50.         case SOCK_RAW:  
  51.             if (!suser()) //超级用户才能处理  
  52.             {  
  53.                 kfree_s((void *)sk, sizeof(*sk));  
  54.                 return(-EPERM);  
  55.             }  
  56.             if (!protocol)// 原始套接字类型，这里表示端口号  
  57.             {  
  58.                 kfree_s((void *)sk, sizeof(*sk));  
  59.                 return(-EPROTONOSUPPORT);  
  60.             }  
  61.             prot = &raw_prot;  
  62.             sk->reuse = 1;  
  63.             sk->no_check = 0;    /* 
  64.                          * Doesn't matter no checksum is 
  65.                          * performed anyway. 
  66.                          */  
  67.             sk->num = protocol;//本地端口号  
  68.             break;  
  69.   
  70.         case SOCK_PACKET:  
  71.             if (!suser())   
  72.             {  
  73.                 kfree_s((void *)sk, sizeof(*sk));  
  74.                 return(-EPERM);  
  75.             }  
  76.             if (!protocol)   
  77.             {  
  78.                 kfree_s((void *)sk, sizeof(*sk));  
  79.                 return(-EPROTONOSUPPORT);  
  80.             }  
  81.             prot = &packet_prot;  
  82.             sk->reuse = 1;  
  83.             sk->no_check = 0;    /* Doesn't matter no checksum is 
  84.                          * performed anyway. 
  85.                          */  
  86.             sk->num = protocol;  
  87.             break;  
  88.   
  89.         default://不符合以上任何类型，则返回  
  90.             kfree_s((void *)sk, sizeof(*sk));  
  91.             return(-ESOCKTNOSUPPORT);  
  92.     }  
  93.     sk->socket = sock;//建立与其对应的socket之间的关系  
  94. #ifdef CONFIG_TCP_NAGLE_OFF  
  95.     sk->nonagle = 1;//如果定义了Nagle算法  
  96. #else      
  97.     sk->nonagle = 0;  
  98. #endif    
  99.     //各种初始化  
  100.     //这里是sock结构  
  101.     sk->type = sock->type;  
  102.     sk->stamp.tv_sec=0;  
  103.     sk->protocol = protocol;  
  104.     sk->wmem_alloc = 0;  
  105.     sk->rmem_alloc = 0;  
  106.     sk->sndbuf = SK_WMEM_MAX;  
  107.     sk->rcvbuf = SK_RMEM_MAX;  
  108.     sk->pair = NULL;  
  109.     sk->opt = NULL;  
  110.     sk->write_seq = 0;  
  111.     sk->acked_seq = 0;  
  112.     sk->copied_seq = 0;  
  113.     sk->fin_seq = 0;  
  114.     sk->urg_seq = 0;  
  115.     sk->urg_data = 0;  
  116.     sk->proc = 0;  
  117.     sk->rtt = 0;             /*TCP_WRITE_TIME << 3;*/  
  118.     sk->rto = TCP_TIMEOUT_INIT;      /*TCP_WRITE_TIME*/  
  119.     sk->mdev = 0;  
  120.     sk->backoff = 0;  
  121.     sk->packets_out = 0;  
  122.     sk->cong_window = 1; /* start with only sending one packet at a time. */  
  123.     sk->cong_count = 0;  
  124.     sk->ssthresh = 0;  
  125.     sk->max_window = 0;  
  126.     sk->urginline = 0;  
  127.     sk->intr = 0;  
  128.     sk->linger = 0;  
  129.     sk->destroy = 0;  
  130.     sk->priority = 1;  
  131.     sk->shutdown = 0;  
  132.     sk->keepopen = 0;  
  133.     sk->zapped = 0;  
  134.     sk->done = 0;  
  135.     sk->ack_backlog = 0;  
  136.     sk->window = 0;  
  137.     sk->bytes_rcv = 0;  
  138.     sk->state = TCP_CLOSE;  
  139.     sk->dead = 0;  
  140.     sk->ack_timed = 0;  
  141.     sk->partial = NULL;  
  142.     sk->user_mss = 0;  
  143.     sk->debug = 0;  
  144.   
  145.     /* this is how many unacked bytes we will accept for this socket.  */  
  146.     sk->max_unacked = 2048; /* needs to be at most 2 full packets. */  
  147.   
  148.     /* how many packets we should send before forcing an ack.  
  149.        if this is set to zero it is the same as sk->delay_acks = 0 */  
  150.     sk->max_ack_backlog = 0;  
  151.     sk->inuse = 0;  
  152.     sk->delay_acks = 0;  
  153.     skb_queue_head_init(&sk->write_queue);  
  154.     skb_queue_head_init(&sk->receive_queue);  
  155.     sk->mtu = 576;//最大传输单元  
  156.     sk->prot = prot;  
  157.     sk->sleep = sock->wait;  
  158.     sk->daddr = 0;//远端地址  
  159.     sk->saddr = 0 /* 本地地址 */;  
  160.     sk->err = 0;  
  161.     sk->next = NULL;  
  162.     sk->pair = NULL;  
  163.     sk->send_tail = NULL;  
  164.     sk->send_head = NULL;  
  165.     sk->timeout = 0;  
  166.     sk->broadcast = 0;  
  167.     sk->localroute = 0;  
  168.     init_timer(&sk->timer);  
  169.     init_timer(&sk->retransmit_timer);  
  170.     sk->timer.data = (unsigned long)sk;  
  171.     sk->timer.function = &net_timer;  
  172.     skb_queue_head_init(&sk->back_log);  
  173.     sk->blog = 0;  
  174.     sock->data =(void *) sk;  
  175.   
  176.     //下面是sock结构中tcp首部初始化  
  177.     sk->dummy_th.doff = sizeof(sk->dummy_th)/4;  
  178.     sk->dummy_th.res1=0;  
  179.     sk->dummy_th.res2=0;  
  180.     sk->dummy_th.urg_ptr = 0;  
  181.     sk->dummy_th.fin = 0;  
  182.     sk->dummy_th.syn = 0;  
  183.     sk->dummy_th.rst = 0;  
  184.     sk->dummy_th.psh = 0;  
  185.     sk->dummy_th.ack = 0;  
  186.     sk->dummy_th.urg = 0;  
  187.     sk->dummy_th.dest = 0;  
  188.     //ip部分  
  189.     sk->ip_tos=0;  
  190.     sk->ip_ttl=64;  
  191. #ifdef CONFIG_IP_MULTICAST  
  192.     sk->ip_mc_loop=1;  
  193.     sk->ip_mc_ttl=1;  
  194.     *sk->ip_mc_name=0;  
  195.     sk->ip_mc_list=NULL;  
  196. #endif  
  197.       
  198.     sk->state_change = def_callback1;  
  199.     sk->data_ready = def_callback2;  
  200.     sk->write_space = def_callback3;  
  201.     sk->error_report = def_callback1;  
  202.   
  203.     if (sk->num) //如果分配了本地端口号  
  204.     {  
  205.     /* 
  206.      * It assumes that any protocol which allows 
  207.      * the user to assign a number at socket 
  208.      * creation time automatically 
  209.      * shares. 
  210.      */  
  211.      //将具有确定端口号的新sock结构加入到sock_array数组表示的sock结构链表中  
  212.         put_sock(sk->num, sk);//实际上这里确定的端口号一般为初始化0  
  213.         sk->dummy_th.source = ntohs(sk->num);//tcp首部源端地址，就是端口号  
  214.         //这里需要进行字节序转换，网络字节序转主机字节序  
  215.     }  
  216.   
  217.     if (sk->prot->init) //根据不同协议类型，调用对应init函数  
  218.     {  
  219.         err = sk->prot->init(sk);//调用相对应4层协议的初始化函数  
  220.         if (err != 0)   
  221.         {  
  222.             destroy_sock(sk);//出错了，就销毁  
  223.             return(err);  
  224.         }  
  225.     }  
  226.     return(0);  
  227. }  
到这里一个 socket 套接字就创建完成了
可以看出socket 套接字的创建过程为：socket() -> sock_socket() -> inet_create() 

我们简单的总结一下这几个函数的功能：

sock_socket() 内部的主要结构是 socket 结构体，其主要负责socket 结构体的创建（sock_alloc()）和初始化，以及指定socket套接字的类型和操作函数集，然后分配一个文件描述符作为socket套接字的操作句柄，该描述符就是我们常说的套接字描述符。socket 的创建主要是分配一个inode 对象来说实现的。inode 对面内部有一个 union 类型变量，里面包含了各种类型的结构体，这里采用的 socket 类型，然后二者建立关联，inode中的union采用socket，socket结构中的inode指针指向该inode对象。

inet_create() 内部的主要结构是 sock 结构体，sock 结构体比socket 结构更显复杂，其使用范围也更为广泛，socket 结构体是一个通用的结构，不涉及到具体的协议，而sock 结构则与具体的协议挂钩，属于具体层面上的一个结构。inet_create 函数的主要功能则是创建一个 sock 结构（kmalloc()）然后根据上层传值下来的协议（通常是类型与地址族组合成成对应的协议）进行初始化。最后将创建好的 sock 结构插入到 sock 表中。

网络栈的更下层用到的套接字就是 sock 结构体，在inet_create 函数中sock 套接字已经创建且初始化，socket() 至此完成。

有了源码，更清楚的了解到socket 函数的功能：创建套接字（sock struct），指定期望的通信协议类型。

到了这一步，套接字拥有自己的实体部分，指定了通信协议类型，但是既没有绑定本地地址信息（ip地址和端口号），也不知道对端的地址信息。



posted @ 2016-10-15 16:26  张同光  阅读(325)  评论(0)  编辑  收藏  举报