[源码分析]-socket的创建

[源码分析]-socket的创建

这节主要介绍下socket创建的大致流程，我们只关注总体流程，流程总有很多细节，我们暂不去讨论，随着阅读源码量的增加，这些细节问题会迎刃而解，有些机制会在后续其他章节介绍，以免影响此节主要内容分析。
下面是创建socket的主体流程。

static int __sock_create(struct net *net, int family, int type, int protocol, struct socket **res, int kern)
{

    struct socket *sock;
    const struct net_proto_family *pf;

    sock = sock_alloc();
    sock->type = type;

    if (net_families[family] == NULL)
        request_module("net-pf-%d", family);

    pf = rcu_dereference(net_families[family]);
    pf->create(net, sock, protocol);

    *res = sock;

    return 0;
}

从上面的内容可以看出，create_socket 主体就两个流程： sock_alloc 以及pf->create钩子函数。下面具体分析

1. sock_alloc

static struct socket *sock_alloc(void)
{
    struct inode *inode;
    struct socket *sock;

    inode = new_inode(sock_mnt->mnt_sb);
    sock = SOCKET_I(inode);
    ...

    return sock;
}

1.1 new_inode

从文件系统中获取socket相关的inode节点。
new_inode->alloc_inode->sock_alloc_inode[sb->s_op->alloc_inode]

struct socket_alloc {
    struct socket socket;    // socket 对象
    struct inode vfs_inode;  // inode 对象， socket_alloc 两者进行绑定
};
static struct inode *sock_alloc_inode(struct super_block *sb)
{
    struct socket_alloc *ei;

    ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
    if (!ei)
        return NULL;
    init_waitqueue_head(&ei->socket.wait);

    ei->socket.fasync_list = NULL;
    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;
}

其中sock_inode_cachep变量就是穿件的cache对象，在init函数中会通过kmem_cache_create来创建，可以通过下面的命令查看分配的情况

root@ubuntu:/# cat /proc/slabinfo  | grep sock_inode_cache
sock_inode_cache     175    175    640   25    4 : tunables    0    0    0 : slabdata      7      7      0

1.2 SOCK_I

static inline struct socket *SOCKET_I(struct inode *inode)
{
    return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}

#define container_of(ptr, type, member) ({  \
    // tpyeof 参数不能为存储类说明符extern static，但是能为类型限定符const volatile
    const typeof( ((type *)0->member ) *__mptr = (ptr);  \
    (type *)( (char *)__mptr - offsetof(type,member) );  \
})

#define offsetof(type, member) ((size_t)&((type *)0 -> member)

对于这个技巧用的还是比较多的，常见如链表，一般会将链表的结构体放在对象里面，知道了链表节点地址，将其转换为对应对象的地址。

2. pf->create

2.1 协议族函数注册

以AF_INET(af_inet.c)协议为例

fs_initcall(inet_init); //将inet_init安装到initcall中去

关于initcall以后再学习介绍。// todo
通过这样的注册，linux在初始化的时候会执行inet_init()函数，下面分析下这个函数：

static int __init inet_init(void)
{
... //省略，只关注inet_family_ops这块
    (void)sock_register(&inet_family_ops);
...
}

int sock_register(const struct net_proto_family *ops)
{
...
    net_families[ops->family] = ops;
...
}

static struct net_proto_family inet_family_ops = {
    .family = PF_INET,   // 即AF_INET（IPV4 地址族、协议族） 2
    .create = inet_create,
    .owner  = THIS_MODULE,
};

到这里，我么就清楚上面 pf->create 指的是什么了

2.2 协议结构体初始化

static int inet_create(struct net *net, struct socket *sock, int protocol)
{
...
    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;
    }

/* Upon startup we insert all the elements in inetsw_array[] into
 * the linked list inetsw.
 */
static struct inet_protosw inetsw_array[] =
{
    {
        .type =       SOCK_STREAM,
        .protocol =   IPPROTO_TCP,
        .prot =       &tcp_prot,
        .ops =        &inet_stream_ops,
        .capability = -1,
        .no_check =   0,
        .flags =      INET_PROTOSW_PERMANENT |
                  INET_PROTOSW_ICSK,
    },

    {
        .type =       SOCK_DGRAM,
        .protocol =   IPPROTO_UDP,
        .prot =       &udp_prot,
        .ops =        &inet_dgram_ops,
        .capability = -1,
        .no_check =   UDP_CSUM_DEFAULT,
        .flags =      INET_PROTOSW_PERMANENT,
       },


       {
           .type =       SOCK_RAW,
           .protocol =   IPPROTO_IP,    /* wild card */
           .prot =       &raw_prot,
           .ops =        &inet_sockraw_ops,
           .capability = CAP_NET_RAW,
           .no_check =   UDP_CSUM_DEFAULT,
           .flags =      INET_PROTOSW_REUSE,
       }
};

上面这段代码根据类型和协议在inetsw_array数组中找到对应的协议处理接口。可以反映为什么在创建socket时，第三个参数protocal可以为0(IPPROTO_IP)。关于注册逻辑可以查看inet_register_protosw

    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;
    }
...
    sock->ops = answer->ops;
    answer_prot = answer->prot; // 传输层使用的协议结构（socket layer -> transport layer interface）
    answer_no_check = answer->no_check;
    answer_flags = answer->flags;
    rcu_read_unlock();

    WARN_ON(answer_prot->slab == NULL);

    err = -ENOBUFS;
    sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot); // 返回sock指针，实际上分配的是tcp_sock(第一个元素是inet_connection_sock， 而inet_connection_sock 第一个元素是inet_sock， 同时inet_sock第一个元素是sock)
    if (sk == NULL)
        goto out;

    err = 0;
    sk->sk_no_check = answer_no_check;
    if (INET_PROTOSW_REUSE & answer_flags)
        sk->sk_reuse = 1;

    inet = inet_sk(sk); // 指针转换： sock => inet_sock
... 
    // sock结构数据初始化
    sock_init_data(sock, sk);
...
    // 协议初始化 sk_prot = sk->sk_prot_creator = prot (inetsw_array)
    if (sk->sk_prot->init) {
        err = sk->sk_prot->init(sk);
        if (err)
            sk_common_release(sk);
    }
...
}

这样，socket结构的初始化工作就完成了，其中涉及的结构体有struct sock struct socket struct sk_buff struct net_sock struct inet_connect_sock 它们之间的关系看下源码也就清楚了，这里也就不展示了。
初始化的总体思路：首先通过sock_alloc进行内存资源分配创建sock_alloc(包含socket和vfs_inode)，之后调用协议族net_families[family]注册的函数create进行协议初始化的工作，依次初始socket、sock、tcp_sock等结构体信息。

参考:

1. 《追踪Linux TCP/IP 代码运行》
2. linux-2.6.32