retval = sock_create(family, type, protocol, &sock);

int sock_create(int family, int type, int protocol, struct socket **res)
{
    return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}

struct nsproxy {
    atomic_t count;
    struct uts_namespace *uts_ns;
    struct ipc_namespace *ipc_ns;
    struct mnt_namespace *mnt_ns;
    struct pid_namespace *pid_ns;
    struct net      *net_ns;
};

static int __sock_create(struct net *net, int family, int type, int protocol,
             struct socket **res, int kern)
{
    int err;
    struct socket *sock;
    const struct net_proto_family *pf;

/*
     * Check protocol is in range
     */
    if (family < 0 || family >= NPROTO)
        return -EAFNOSUPPORT;
    if (type < 0 || type >= SOCK_MAX)
        return -EINVAL;

/*
     * Skip some codes
     */

}

/* Compatibility.

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

err = security_socket_create(family, type, protocol, kern);
    if (err)
        return err;

static struct inode *alloc_inode(struct super_block *sb)
{
struct inode *inode;
return inode;
}

struct inode *new_inode_pseudo(struct super_block *sb)
{
struct inode *inode = alloc_inode(sb);
return inode;
}

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

inode = new_inode_pseudo(sock_mnt->mnt_sb);
    if (!inode)
        return NULL;

sock = SOCKET_I(inode);

kmemcheck_annotate_bitfield(sock, type);
    inode->i_mode = S_IFSOCK | S_IRWXUGO;
    inode->i_uid = current_fsuid();
    inode->i_gid = current_fsgid();

percpu_add(sockets_in_use, 1);
    return sock;
}

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

rcu_read_lock();
    pf = rcu_dereference(net_families[family]);
    err = -EAFNOSUPPORT;
    if (!pf)
        goto out_release;

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

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

err = pf->create(net, sock, protocol, kern);
    if (err < 0)
        goto out_module_put;

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

/*
     * Now that we're done with the ->create function, the [loadable]
     * module can have its refcnt decremented
     */
    module_put(pf->owner);
    err = security_socket_post_create(sock, family, type, protocol, kern);
    if (err)
        goto out_sock_release;
    *res = sock;

return 0;