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;
    char answer_no_check;
    int try_loading_module = 0;
    int err;

if (unlikely(!inet_ehash_secret))
        if (sock->type != SOCK_RAW && sock->type != SOCK_DGRAM)
            build_ehash_secret();

/* 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;
    }

static struct list_head inetsw[SOCK_MAX];

static int __init inet_init(void)
{
    /*

Skip some codes

*/

/* Register the socket-side information for inet_create. */
    for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
        INIT_LIST_HEAD(r);

for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
        inet_register_protosw(q);

/* 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,
        .no_check = 0,
        .flags = INET_PROTOSW_PERMANENT |
             INET_PROTOSW_ICSK,
    },

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

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

sock->ops = answer->ops;
    answer_prot = answer->prot;
    answer_no_check = answer->no_check;
    answer_flags = answer->flags;
    rcu_read_unlock();

const struct proto_ops inet_dgram_ops = {
    .family         = PF_INET,
    .owner         = THIS_MODULE,
    .release     = inet_release,
    .bind         = inet_bind,
    .connect     = inet_dgram_connect,
    .socketpair     = sock_no_socketpair,
    .accept         = sock_no_accept,
    .getname     = inet_getname,
    .poll         = udp_poll,
    .ioctl         = inet_ioctl,
    .listen         = sock_no_listen,
    .shutdown     = inet_shutdown,
    .setsockopt     = sock_common_setsockopt,
    .getsockopt     = sock_common_getsockopt,
    .sendmsg     = inet_sendmsg,
    .recvmsg     = inet_recvmsg,
    .mmap         = sock_no_mmap,
    .sendpage     = inet_sendpage,
#ifdef CONFIG_COMPAT
    .compat_setsockopt = compat_sock_common_setsockopt,
    .compat_getsockopt = compat_sock_common_getsockopt,
#endif
};

struct proto udp_prot = {
    .name         = "UDP",
    .owner         = THIS_MODULE,
    .close         = udp_lib_close,
    .connect     = ip4_datagram_connect,
    .disconnect     = udp_disconnect,
    .ioctl         = udp_ioctl,
    .destroy     = udp_destroy_sock,
    .setsockopt     = udp_setsockopt,
    .getsockopt     = udp_getsockopt,
    .sendmsg     = udp_sendmsg,
    .recvmsg     = udp_recvmsg,
    .sendpage     = udp_sendpage,
    .backlog_rcv     = __udp_queue_rcv_skb,
    .hash         = udp_lib_hash,
    .unhash         = udp_lib_unhash,
    .rehash         = udp_v4_rehash,
    .get_port     = udp_v4_get_port,
    .memory_allocated = &udp_memory_allocated,
    .sysctl_mem     = sysctl_udp_mem,
    .sysctl_wmem     = &sysctl_udp_wmem_min,
    .sysctl_rmem     = &sysctl_udp_rmem_min,
    .obj_size     = sizeof(struct udp_sock),
    .slab_flags     = SLAB_DESTROY_BY_RCU,
    .h.udp_table     = &udp_table,
#ifdef CONFIG_COMPAT
    .compat_setsockopt = compat_udp_setsockopt,
    .compat_getsockopt = compat_udp_getsockopt,
#endif
};

err = -ENOBUFS;
     sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);
     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);
     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 (ipv4_config.no_pmtu_disc)
          inet->pmtudisc = IP_PMTUDISC_DONT;
     else
          inet->pmtudisc = IP_PMTUDISC_WANT;

inet->inet_id = 0;

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->uc_ttl = -1;
     inet->mc_loop = 1;
     inet->mc_ttl = 1;
     inet->mc_all = 1;
     inet->mc_index = 0;
     inet->mc_list = NULL;

sk_refcnt_debug_inc(sk);

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. */
          sk->sk_prot->hash(sk);
     }

if (sk->sk_prot->init) {
          err = sk->sk_prot->init(sk);
          if (err)
               sk_common_release(sk);
     }