socket创建过程

3220阅读　0评论2013-12-10　liubangbo
分类：LINUX

对于网络编程程序员来说sockfd = socket(AF_INET, SOCKET_DGRM, 0);这行代码是最熟悉不过，但这行代码的背后是......

1. socket这个api是库函数，我们直接调用就可以了，调用之后，产生0x80号软中断，linux系统由用户态切换到内核态，接着执行系统调用函数，在内核态执行相应的服务例程，针对socket这个函数，服务例程
   是sys_socket函数。至于这个过程是怎么实现的，在这里不阐述。下面我们分析sys_socket函数，看socket是怎么创建的。

2. 在分析sys_socket函数之前，我们先看一下sock_init初始化过程
   

点击(此处)折叠或打开

  1. static int __init sock_init(void)
  2. {
  3.     /*
  4.      * Initialize sock SLAB cache.
  5.      */

  7.     sk_init(); 

  9.     /*
  10.      * Initialize skbuff SLAB cache
  11.      */
  12.     skb_init();

  14.     /*
  15.      * Initialize the protocols module.
  16.      */

  18.     init_inodecache();   //在这里创建了名为sock_inode_cache的cache
  19.     register_filesystem(&sock_fs_type);
  20.     sock_mnt = kern_mount(&sock_fs_type);

  22.     /* The real protocol initialization is performed in later initcalls.
  23.      */

  25. #ifdef CONFIG_NETFILTER
  26.     netfilter_init();
  27. #endif

  29.     return 0;
  30. }



     struct socket_alloc {
               struct socket socket;
               struct inode vfs_inode;
     };

  
     static int init_inodecache(void)
     {
        sock_inode_cachep = kmem_cache_create("sock_inode_cache",
                          sizeof(struct socket_alloc),         //在这里创建了名为sock_inode_cache，大小为sizeof(struct socket_alloc)的slab高速缓存  
                                                              //猜测创建slab高速缓存，而不是普通内存，那么操作socket结构就快了
                          0,
                          (SLAB_HWCACHE_ALIGN |
                           SLAB_RECLAIM_ACCOUNT |
                           SLAB_MEM_SPREAD),
                          init_once,
                          NULL);
        if (sock_inode_cachep == NULL)
            return -ENOMEM;
        return 0;
     }

     static struct vfsmount *sock_mnt __read_mostly;

     static struct file_system_type sock_fs_type = {    
             .name =        "sockfs",
             .get_sb =    sockfs_get_sb,
             .kill_sb =    kill_anon_super,
     };
    
     register_filesystem(&sock_fs_type);   //在这里注册了名为sockfs的VFS
     sock_mnt = kern_mount(&sock_fs_type);  //并在这里得到struct vfsmount 结构的sock_mnt变量，这个变量是全局变量，在创建socket的时候会用到

     static struct super_operations sockfs_ops = {
          .alloc_inode =    sock_alloc_inode,      //这里就是最终创建struct socket_alloc结构的函数
          .destroy_inode =sock_destroy_inode,
          .statfs =    simple_statfs,
     };

     static int sockfs_get_sb(struct file_system_type *fs_type,
             int flags, const char *dev_name, void *data,
             struct vfsmount *mnt)
     {
          return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,
                                  mnt);
     }

     static struct inode *sock_alloc_inode(struct super_block *sb)
     {
          struct socket_alloc *ei;

          ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);  //在这里我们看到了memory allocate 操作
          if (!ei)
              return NULL;
          init_waitqueue_head(&ei->socket.wait);

          ei->socket.fasync_list = NULL;          //在这里对socket结构一些字段进行了初始化
          ei->socket.state = SS_UNCONNECTED;
          ei->socket.flags = 0;
          ei->socket.ops = NULL;
          ei->socket.sk = NULL;
          ei->socket.file = NULL;

          return &ei->vfs_inode;
}


3. 前面进行的这些初始化，为后面做好了准备，接着往下看吧：

 
  

点击(此处)折叠或打开

  1. asmlinkage long sys_socket(int family, int type, int protocol)
  2. {
  3.     int retval;
  4.     struct socket *sock;

  6.     retval = sock_create(family, type, protocol, &sock);  //在这个函数完成了socket的创建过程
  7.     if (retval < 0)
  8.         goto out;

  10.     retval = sock_map_fd(sock);  //把创建的socket和文件相关联，
  11.     if (retval < 0)
  12.         goto out_release;

  14. out:
  15.     /* It may be already another descriptor 8) Not kernel problem. */
  16.     return retval;

  18. out_release:
  19.     sock_release(sock);
  20.     return retval;
  21. }
sock_create函数是封装函数，实际调用的是__sock_create函数

点击(此处)折叠或打开

  1. static int __sock_create(int family, int type, int protocol,
  2.              struct socket **res, int kern)
  3. {
  4.     int err;
  5.     struct socket *sock;
  6.     const struct net_proto_family *pf;

  8.     /*
  9.      * Check protocol is in range
  10.      */
  11.     if (family < 0 || family >= NPROTO)
  12.         return -EAFNOSUPPORT;
  13.     if (type < 0 || type >= SOCK_MAX)
  14.         return -EINVAL;

  16.     /* Compatibility.

  18.      This uglymoron is moved from INET layer to here to avoid
  19.      deadlock in module load.
  20.      */
  21.     if (family == PF_INET && type == SOCK_PACKET) {
  22.         static int warned;
  23.         if (!warned) {
  24.             warned = 1;
  25.             printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",
  26.              current->comm);
  27.         }
  28.         family = PF_PACKET;
  29.     }

  31.     err = security_socket_create(family, type, protocol, kern);
  32.     if (err)
  33.         return err;

  35.     /*
  36.      *    Allocate the socket and allow the family to set things up. if
  37.      *    the protocol is 0, the family is instructed to select an appropriate
  38.      *    default.
  39.      */
  40.     sock = sock_alloc(); //这个函数调用了初始化时注册的创建socket和inode节点的回调函数，完成了socket和inode节点的创建。在unix和类unix系统中把socket当做文件节点来处理，所以有inode节点
  41.                          //后面我们分析这个函数
  42.     if (!sock) {
  43.         if (net_ratelimit())
  44.             printk(KERN_WARNING "socket: no more sockets\n");
  45.         return -ENFILE;    /* Not exactly a match, but its the
  46.                  closest posix thing */
  47.     }

  49.     sock->type = type;

  51. #if defined(CONFIG_KMOD)
  52.     /* Attempt to load a protocol module if the find failed.
  53.      *
  54.      * 12/09/1996 Marcin: this makes REALLY only sense, if the user
  55.      * requested real, full-featured networking support upon configuration.
  56.      * Otherwise module support will
  57.      */
  58.     if (net_families[family] == NULL)
  59.         request_module("net-pf-%d", family);
  60. #endif

  62.     rcu_read_lock();
  63.     pf = rcu_dereference(net_families[family]);  //根据协议族family得到struct net_proto_family结构，这个net_families数组在inet_init函数中初始化，稍后我们看看这个初始化过程
  64.     err = -EAFNOSUPPORT;
  65.     if (!pf)
  66.         goto out_release;

  68.     /*
  69.      * We will call the ->create function, that possibly is in a loadable
  70.      * module, so we have to bump that loadable module refcnt first.
  71.      */
  72.     if (!try_module_get(pf->owner))
  73.         goto out_release;

  75.     /* Now protected by module ref count */
  76.     rcu_read_unlock();

  78.     err = pf->create(sock, protocol); //在这里创建了庞大的struct sock 结构，并进行了初始化。这个挂入的inet_create函数
  79.     if (err < 0)
  80.         goto out_module_put;

  82.     /*
  83.      * Now to bump the refcnt of the [loadable] module that owns this
  84.      * socket at sock_release time we decrement its refcnt.
  85.      */
  86.     if (!try_module_get(sock->ops->owner))
  87.         goto out_module_busy;

  89.     /*
  90.      * Now that we're done with the ->create function, the [loadable]
  91.      * module can have its refcnt decremented
  92.      */
  93.     module_put(pf->owner);
  94.     err = security_socket_post_create(sock, family, type, protocol, kern);
  95.     if (err)
  96.         goto out_release;
  97.     *res = sock;

  99.     return 0;

  101. out_module_busy:
  102.     err = -EAFNOSUPPORT;
  103. out_module_put:
  104.     sock->ops = NULL;
  105.     module_put(pf->owner);
  106. out_sock_release:
  107.     sock_release(sock);
  108.     return err;

  110. out_release:
  111.     rcu_read_unlock();
  112.     goto out_sock_release;
  113. }
从上面的代码中看到_sock_create函数调用了回调函数完成了socket创建和初始化过程，下面我们看创建socket结构的过程：sock = sock_alloc();

点击(此处)折叠或打开

  1. static struct socket *sock_alloc(void)
  2. {
  3.     struct inode *inode;
  4.     struct socket *sock;

  6.     inode = new_inode(sock_mnt->mnt_sb); //在这里我们看到了sock_init函数中得到的全局变量sock_mnt，稍后看下new_inode函数
  7.     if (!inode)
  8.         return NULL;

  10.     sock = SOCKET_I(inode); //得到了socket结构

  12.     inode->i_mode = S_IFSOCK | S_IRWXUGO;
  13.     inode->i_uid = current->fsuid;
  14.     inode->i_gid = current->fsgid;

  16.     get_cpu_var(sockets_in_use)++;
  17.     put_cpu_var(sockets_in_use);
  18.     return sock;
  19. }
  20. struct inode *new_inode(struct super_block *sb)
    {
        static unsigned long last_ino;
        struct inode * inode;

        spin_lock_prefetch(&inode_lock);
        
        inode = alloc_inode(sb);  //接着看这个函数
        if (inode) {
            spin_lock(&inode_lock);
            inodes_stat.nr_inodes++;
            list_add(&inode->i_list, &inode_in_use);
            list_add(&inode->i_sb_list, &sb->s_inodes);
            inode->i_ino = ++last_ino;
            inode->i_state = 0;
            spin_unlock(&inode_lock);
        }
        return inode;
    }
  21. static struct inode *alloc_inode(struct super_block *sb)
    {
        static const struct address_space_operations empty_aops;
        static struct inode_operations empty_iops;
        static const struct file_operations empty_fops;
        struct inode *inode;

        if (sb->s_op->alloc_inode) //在这里我们看到 if调节满足，因为在sock_init函数中我们挂入了sock_alloc_inode函数，之前我们也看到了sock_alloc_inode函数创建了sizeof(struct socket_alloc
  22.                                //大小的slab高速缓存
            inode = sb->s_op->alloc_inode(sb); 
        else
            inode = (struct inode *) kmem_cache_alloc(inode_cachep, GFP_KERNEL);

        if (inode) {
            struct address_space * const mapping = &inode->i_data;

            inode->i_sb = sb;
            inode->i_blkbits = sb->s_blocksize_bits;
            inode->i_flags = 0;
            atomic_set(&inode->i_count, 1);
            inode->i_op = &empty_iops;
            inode->i_fop = &empty_fops;
            inode->i_nlink = 1;
            atomic_set(&inode->i_writecount, 0);
            inode->i_size = 0;
            inode->i_blocks = 0;
            inode->i_bytes = 0;
            inode->i_generation = 0;
    #ifdef CONFIG_QUOTA
            memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
    #endif
            inode->i_pipe = NULL;
            inode->i_bdev = NULL;
            inode->i_cdev = NULL;
            inode->i_rdev = 0;
            inode->dirtied_when = 0;
            if (security_inode_alloc(inode)) {
                if (inode->i_sb->s_op->destroy_inode)
                    inode->i_sb->s_op->destroy_inode(inode);
                else
                    kmem_cache_free(inode_cachep, (inode));
                return NULL;
            }

            mapping->a_ops = &empty_aops;
             mapping->host = inode;
            mapping->flags = 0;
            mapping_set_gfp_mask(mapping, GFP_HIGHUSER);
            mapping->assoc_mapping = NULL;
            mapping->backing_dev_info = &default_backing_dev_info;

            /*
             * If the block_device provides a backing_dev_info for client
             * inodes then use that.  Otherwise the inode share the bdev's
             * backing_dev_info.
             */
            if (sb->s_bdev) {
                struct backing_dev_info *bdi;

                bdi = sb->s_bdev->bd_inode_backing_dev_info;
                if (!bdi)
                    bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
                mapping->backing_dev_info = bdi;
            }
            inode->i_private = NULL;
            inode->i_mapping = mapping;
        }
        return inode;
    }

       

从上面的分析中我们就可以很好的理解得到socket结构的过程：根据inode 得到socket
sock = SOCKET_I(inode);  
static inline struct socket *SOCKET_I(struct inode *inode)
{
    return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}

4. 现在创建socket结构的过程也就完成了，下面我们看看创建struct sock结构的过程
   在inet_init函数中，
   (void)sock_register(&inet_family_ops);
  static struct net_proto_family inet_family_ops = {
           .family = PF_INET,
           .create = inet_create,
          .owner    = THIS_MODULE,
  };
在这里我们看到了挂入的过程，net_families数组以family为下标，组成了各个协议创建函数，还记得执行create函数的地方吧？但在看这个函数以前先看看这里：

点击(此处)折叠或打开

  1. /* Upon startup we insert all the elements in inetsw_array[] into
  2.  * the linked list inetsw.
  3.  */
  4. static struct inet_protosw inetsw_array[] =
  5. {
  6.     {
  7.         .type = SOCK_STREAM,
  8.         .protocol = IPPROTO_TCP,
  9.         .prot = &tcp_prot,
  10.         .ops = &inet_stream_ops,
  11.         .capability = -1,
  12.         .no_check = 0,
  13.         .flags = INET_PROTOSW_PERMANENT |
  14.              INET_PROTOSW_ICSK,
  15.     },

  17.     {
  18.         .type = SOCK_DGRAM,
  19.         .protocol = IPPROTO_UDP,
  20.         .prot = &udp_prot,
  21.         .ops = &inet_dgram_ops,
  22.         .capability = -1,
  23.         .no_check = UDP_CSUM_DEFAULT,
  24.         .flags = INET_PROTOSW_PERMANENT,
  25.        },


  28.        {
  29.      .type = SOCK_RAW,
  30.      .protocol = IPPROTO_IP,    /* wild card */
  31.      .prot = &raw_prot,
  32.      .ops = &inet_sockraw_ops,
  33.      .capability = CAP_NET_RAW,
  34.      .no_check = UDP_CSUM_DEFAULT,
  35.      .flags = INET_PROTOSW_REUSE,
  36.        }
  37. };

  39. //下面的代码是在inet_init函数中执行的
  40. /* Register the socket-side information for inet_create. */
  41.     for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
  42.         INIT_LIST_HEAD(r);

  44.     for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
  45.         inet_register_protosw(q);
我们来看看struct inet_protosw 这个结构

点击(此处)折叠或打开

  1. /* This is used to register socket interfaces for IP protocols. */
  2. struct inet_protosw {
  3.     struct list_head list;

  5.         /* These two fields form the lookup key. */
  6.     unsigned short     type;     /* This is the 2nd argument to socket(2). */
  7.     unsigned short     protocol; /* This is the L4 protocol number. */

  9.     struct proto     *prot;
  10.     const struct proto_ops *ops;
  11.   
  12.     int capability; /* Which (if any) capability do
  13.                  * we need to use this socket
  14.                  * interface?
  15.                                       */
  16.     char no_check; /* checksum on rcv/xmit/none? */
  17.     unsigned char     flags; /* See INET_PROTOSW_* below. */
  18. };




点击(此处)折叠或打开

  1. /*
  2.  *    Create an inet socket. //从这个注释中我们可以看到，还可以创建其他类型的socket
  3.  */

  5. static int inet_create(struct socket *sock, int protocol)
  6. {
  7.     struct sock *sk;
  8.     struct list_head *p;
  9.     struct inet_protosw *answer;
  10.     struct inet_sock *inet;
  11.     struct proto *answer_prot;
  12.     unsigned char answer_flags;
  13.     char answer_no_check;
  14.     int try_loading_module = 0;
  15.     int err;

  17.     sock->state = SS_UNCONNECTED;

  19.     /* Look for the requested type/protocol pair. */
  20.     answer = NULL;
  21. lookup_protocol:
  22.     err = -ESOCKTNOSUPPORT;
  23.     rcu_read_lock();
  24.     list_for_each_rcu(p, &inetsw[sock->type]) {   //在这里我们遍历inetsw数组，根据是UDP，TCP，RAW类型得到了struct inet_protosw结构
  25.         answer = list_entry(p, struct inet_protosw, list);

  27.         /* Check the non-wild match. */
  28.         if (protocol == answer->protocol) {
  29.             if (protocol != IPPROTO_IP)
  30.                 break;
  31.         } else {
  32.             /* Check for the two wild cases. */
  33.             if (IPPROTO_IP == protocol) {
  34.                 protocol = answer->protocol;
  35.                 break;
  36.             }
  37.             if (IPPROTO_IP == answer->protocol)
  38.                 break;
  39.         }
  40.         err = -EPROTONOSUPPORT;
  41.         answer = NULL;
  42.     }

  44.     if (unlikely(answer == NULL)) {
  45.         if (try_loading_module < 2) {
  46.             rcu_read_unlock();
  47.             /*
  48.              * Be more specific, e.g. net-pf-2-proto-132-type-1
  49.              * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
  50.              */
  51.             if (++try_loading_module == 1)
  52.                 request_module("net-pf-%d-proto-%d-type-%d",
  53.                      PF_INET, protocol, sock->type);
  54.             /*
  55.              * Fall back to generic, e.g. net-pf-2-proto-132
  56.              * (net-pf-PF_INET-proto-IPPROTO_SCTP)
  57.              */
  58.             else
  59.                 request_module("net-pf-%d-proto-%d",
  60.                      PF_INET, protocol);
  61.             goto lookup_protocol;
  62.         } else
  63.             goto out_rcu_unlock;
  64.     }

  66.     err = -EPERM;
  67.     if (answer->capability > 0 && !capable(answer->capability))
  68.         goto out_rcu_unlock;

  70.     sock->ops = answer->ops;    //对socket结构进行了初始化
  71.     answer_prot = answer->prot;
  72.     answer_no_check = answer->no_check;
  73.     answer_flags = answer->flags;
  74.     rcu_read_unlock();

  76.     BUG_TRAP(answer_prot->slab != NULL);

  78.     err = -ENOBUFS;
  79.     sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);   //这个函数创建了struct sock 这个庞然大物
  80.     if (sk == NULL)
  81.         goto out;

  83.     err = 0;
  84.     sk->sk_no_check = answer_no_check;
  85.     if (INET_PROTOSW_REUSE & answer_flags)
  86.         sk->sk_reuse = 1;

  88.     inet = inet_sk(sk);
  89.     inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;

  91.     if (SOCK_RAW == sock->type) {
  92.         inet->num = protocol;
  93.         if (IPPROTO_RAW == protocol)
  94.             inet->hdrincl = 1;
  95.     }

  97.     if (ipv4_config.no_pmtu_disc)
  98.         inet->pmtudisc = IP_PMTUDISC_DONT;
  99.     else
  100.         inet->pmtudisc = IP_PMTUDISC_WANT;

  102.     inet->id = 0;

  104.     sock_init_data(sock, sk);  //在这里对struct sock里面重要的字段进行了初始化，包括接受队列，发送队列，以及长度等

  106.     sk->sk_destruct     = inet_sock_destruct;   
  107.     sk->sk_family     = PF_INET;
  108.     sk->sk_protocol     = protocol;
  109.     sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;

  111.     inet->uc_ttl    = -1;
  112.     inet->mc_loop    = 1;
  113.     inet->mc_ttl    = 1;
  114.     inet->mc_index    = 0;
  115.     inet->mc_list    = NULL;

  117.     sk_refcnt_debug_inc(sk);

  119.     if (inet->num) {    //我们看到当我们调用RAW类型的socket的时候，这个if条件就成立了
  120.         /* It assumes that any protocol which allows
  121.          * the user to assign a number at socket
  122.          * creation time automatically
  123.          * shares.
  124.          */
  125.         inet->sport = htons(inet->num);
  126.         /* Add to protocol hash chains. */
  127.         sk->sk_prot->hash(sk);
  128.     }

  130.     if (sk->sk_prot->init) {           //看L4层是否注册了初始化函数，我们看到UDP类型的socket为空，而TCP类型的socket注册了初始化函数
  131.         err = sk->sk_prot->init(sk);
  132.         if (err)
  133.             sk_common_release(sk);
  134.     }
  135. out:
  136.     return err;
  137. out_rcu_unlock:
  138.     rcu_read_unlock();
  139.     goto out;
  140. }

点击(此处)折叠或打开

  1. void sock_init_data(struct socket *sock, struct sock *sk)
  2. {
  3.     skb_queue_head_init(&sk->sk_receive_queue); //接受队列
  4.     skb_queue_head_init(&sk->sk_write_queue);   //发送队列
  5.     skb_queue_head_init(&sk->sk_error_queue);
  6. #ifdef CONFIG_NET_DMA
  7.     skb_queue_head_init(&sk->sk_async_wait_queue);
  8. #endif

  10.     sk->sk_send_head    =    NULL;

  12.     init_timer(&sk->sk_timer);

  14.     sk->sk_allocation    =    GFP_KERNEL;
  15.     sk->sk_rcvbuf        =    sysctl_rmem_default;  //接受缓冲区大小
  16.     sk->sk_sndbuf        =    sysctl_wmem_default;  //发送缓冲区大小
  17.     sk->sk_state        =    TCP_CLOSE;   //被初始化为TCP_CLOSE，再下一篇绑定分析中我们会看到会检查这个状态
  18.     sk->sk_socket        =    sock;

  20.     sock_set_flag(sk, SOCK_ZAPPED);

  22.     if(sock)
  23.     {
  24.         sk->sk_type    =    sock->type;
  25.         sk->sk_sleep    =    &sock->wait;
  26.         sock->sk    =    sk;
  27.     } else
  28.         sk->sk_sleep    =    NULL;

  30.     rwlock_init(&sk->sk_dst_lock);
  31.     rwlock_init(&sk->sk_callback_lock);
  32.     lockdep_set_class(&sk->sk_callback_lock,
  33.              af_callback_keys + sk->sk_family);

  35.     sk->sk_state_change    =    sock_def_wakeup;
  36.     sk->sk_data_ready    =    sock_def_readable;
  37.     sk->sk_write_space    =    sock_def_write_space;
  38.     sk->sk_error_report    =    sock_def_error_report;
  39.     sk->sk_destruct        =    sock_def_destruct;

  41.     sk->sk_sndmsg_page    =    NULL;
  42.     sk->sk_sndmsg_off    =    0;

  44.     sk->sk_peercred.pid     =    0;
  45.     sk->sk_peercred.uid    =    -1;
  46.     sk->sk_peercred.gid    =    -1;
  47.     sk->sk_write_pending    =    0;
  48.     sk->sk_rcvlowat        =    1;
  49.     sk->sk_rcvtimeo        =    MAX_SCHEDULE_TIMEOUT;
  50.     sk->sk_sndtimeo        =    MAX_SCHEDULE_TIMEOUT;

  52.     sk->sk_stamp.tv_sec = -1L;
  53.     sk->sk_stamp.tv_usec = -1L;

  55.     atomic_set(&sk->sk_refcnt, 1);
  56. }
就写到这个程度吧，代码里面有很多对方没有明白，以后明白了再加上......




上一篇：数据包在L4被挂入接收队列过程
下一篇：bind函数