Linux源码-sys_socket()

（本文部分参考《Linux内核源代码情景分析》）
本文主要介绍函数sys_socket()在内核中的实现。
1、系统调用总入口： sys_socketcall()
Linux 内核为所有与 socket 有关的操作提供了一个统一的系统调用入口，但是在用户程序界面上则通过 C 语言程序库 c.lib 提供诸多库函数，看起来好像都是独立的系统调用一样。内核中为 socket 设置的总入口为 sys_socketcall()，其代码在 net/socket.c ：

/*与socket相关的系统调用总入口。 */
/*
*函数的第一个参数 call 即为具体的操作码，而参数 args 为指向一个数组的指针，可以根据具体操作码的不同，确定从用户空间复制参数的数量；
*/
asmlinkage long sys_socketcall(int call, unsigned long __user *args)
{
    unsigned long a[6];
    unsigned long a0,a1;
    int err;

    if(call<1||call>SYS_RECVMSG)
        return -EINVAL;

    /* copy_from_user should be SMP safe. */
    if (copy_from_user(a, args, nargs[call]))
        return -EFAULT;

    a0=a[0];
    a1=a[1];

    switch(call) 
    {
        case SYS_SOCKET:
            err = sys_socket(a0,a1,a[2]);
            break;
        case SYS_BIND:
            err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);
            break;
        case SYS_CONNECT:
            err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
            break;
        case SYS_LISTEN:
            err = sys_listen(a0,a1);
            break;
        case SYS_ACCEPT:
            err = sys_accept(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
            break;
        case SYS_GETSOCKNAME:
            err = sys_getsockname(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
            break;
        case SYS_GETPEERNAME:
            err = sys_getpeername(a0, (struct sockaddr __user *)a1, (int __user *)a[2]);
            break;
        case SYS_SOCKETPAIR:
            err = sys_socketpair(a0,a1, a[2], (int __user *)a[3]);
            break;
        case SYS_SEND:
            err = sys_send(a0, (void __user *)a1, a[2], a[3]);
            break;
        case SYS_SENDTO:
            err = sys_sendto(a0,(void __user *)a1, a[2], a[3],
                     (struct sockaddr __user *)a[4], a[5]);
            break;
        case SYS_RECV:
            err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
            break;
        case SYS_RECVFROM:
            err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
                       (struct sockaddr __user *)a[4], (int __user *)a[5]);
            break;
        case SYS_SHUTDOWN:
            err = sys_shutdown(a0,a1);
            break;
        case SYS_SETSOCKOPT:
            err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
            break;
        case SYS_GETSOCKOPT:
            err = sys_getsockopt(a0, a1, a[2], (char __user *)a[3], (int __user *)a[4]);
            break;
        case SYS_SENDMSG:
            err = sys_sendmsg(a0, (struct msghdr __user *) a1, a[2]);
            break;
        case SYS_RECVMSG:
            err = sys_recvmsg(a0, (struct msghdr __user *) a1, a[2]);
            break;
        default:
            err = -EINVAL;
            break;
    }
    return err;
}

2、函数sys_socket()——创建插口
操作 SYS_SOCKET 是由 sys_socket()实现的，其代码在 net/socket.c 中：

asmlinkage long sys_socket(int family, int type, int protocol)
{
    int retval;
    struct socket *sock;

    /* 根据协议族、套口类型、传输层协议创建套口 */
    retval = sock_create(family, type, protocol, &sock);
    if (retval < 0)
        goto out;

    /* 为创建的套接口分配一个文件描述符并进行绑定 */
    retval = sock_map_fd(sock);
    if (retval < 0)
        goto out_release;

out:
    return retval;

out_release:
    sock_release(sock);
    return retval;
}

sys_socket()函数中主体函数由两个函数实现：sock_create()和sock_map_fd(),接下来分别介绍。
2.1 sock_create()只是起了中转作用，它调用了函数__sock_create():

int sock_create(int family, int type, int protocol, struct socket **res)
{
    /* 传入0表示是用户态进程创建套接口 */
    return __sock_create(family, type, protocol, res, 0);
}

函数__sock_create()代码如下：

/**
 * 创建一个套接口
 *  family:     套接口协议族
 *  type:       套接口类型
 *  protocol:       传输层协议
 *  res:            输出参数，创建成功的套接口指针
 *  kern:       由内核还是应用程序创建。
 */
static int __sock_create(int family, int type, int protocol, struct socket **res, int kern)
{
    int err;
    struct socket *sock;

    if (family < 0 || family >= NPROTO)/* 参数合法性检测 */
        return -EAFNOSUPPORT;
    if (type < 0 || type >= SOCK_MAX)
        return -EINVAL;
    /**
     * IPV4协议族的SOCK_PACKET类型套接口已经不被支持
     * 为兼容旧程序，转换为PF_PACKET 
*/
    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;

#if defined(CONFIG_KMOD)
    if (net_families[family]==NULL)/* 相应的协议族在内核中尚不存在，加载模块以支持该协议族 */
    {
        request_module("net-pf-%d",family);
    }
#endif

    /* 等待，直到锁被释放 */
    net_family_read_lock();
    if (net_families[family] == NULL) {/* 如果协议族仍然不存在，说明不支持此协议族 */
        err = -EAFNOSUPPORT;
        goto out;
    }


    if (!(sock = sock_alloc())) {/* 分配与inode关联的套接口 */
        printk(KERN_WARNING "socket: no more sockets\n");
        err = -ENFILE;      
        goto out;
    }

    sock->type  = type;/* 设置套接口类型。 */

    err = -EAFNOSUPPORT;
    if (!try_module_get(net_families[family]->owner))/* 增加对协议族模块的引用，如果失败则退出 */
        goto out_release;

    /* 调用协议族的创建方法，对IPV4来说，调用的是inet_create */
    if ((err = net_families[family]->create(sock, protocol)) < 0)
        goto out_module_put;
    if (!try_module_get(sock->ops->owner)) {/* 增加传输层模块的引用计数 */
        sock->ops = NULL;
        goto out_module_put;
    }
    /* 增加了传输层模块的引用计数后，可以释放协议族的模块引用计数 */
    module_put(net_families[family]->owner);
    *res = sock;
    /* 通知安全模块，对创建过程进行检查。 */
    security_socket_post_create(sock, family, type, protocol, kern);

out:
    net_family_read_unlock();
    return err;
out_module_put:
    module_put(net_families[family]->owner);
out_release:
    sock_release(sock);
    goto out;
}

本函数中sock_alloc()函数和inet_create()函数最为关键。

2.1.1 函数 sock_alloc()分配一个 socket 数据结构并进行一些初始化：

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

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

    sock = SOCKET_I(inode);

/*
*在 inode 结构中还要将 i_mode 里的 S_IFSOCK 标志位设成 1，并将 i_sock 也设成 1，以示这个 inode 结构所代表的并不是磁盘文件，而是一个插口。
*/
    inode->i_mode = S_IFSOCK|S_IRWXUGO;
    inode->i_sock = 1;
    inode->i_uid = current->fsuid;
    inode->i_gid = current->fsgid;

    get_cpu_var(sockets_in_use)++;
    put_cpu_var(sockets_in_use);
    return sock;
}

由上述代码可知，取得一个 inode 结构是取得一个 socket 结构的必要条件。不仅如此， socket 结构其实只是 inode结构中的一部分。具体数据结构参看文末。
实际上，本函数主体功能又分担给两个函数new_inode()和sock = SOCKET_I()；
2.1.1.1

struct inode *new_inode(struct super_block *sb)
{
    ...
    inode = alloc_inode(sb);
    if (inode) {
        ...
    }
    return inode;
}

在本函数中，首先通过函数alloc_inode(sb)创建一个inode节点，然后对节点进行一些设置。
alloc_inode()代码如下：

static struct inode *alloc_inode(struct super_block *sb)
{
    /*
*如果当前文件系统超级块有自己分配inode节点的操作函数就调用自己的，否则从公用高速缓冲区分配一块inode
*/
    if (sb->s_op->alloc_inode)
        inode = sb->s_op->alloc_inode(sb);
    else
        inode = (struct inode *) kmem_cache_alloc(inode_cachep, SLAB_KERNEL);

    ...
    return inode;
}

2.1.1.2 在 inode 结构中有一个关键性的成分 u。这是一个 union，要按具体的文件类型和格式而解释成不同的数据结构。目前 Linux 支持 20 多种不同的文件系统，因此对这个 union 有 20 多种不同的解释，而 socket 结构正是其中之一。sock = SOCKET_I(inode);只是将 inode 结构中的这个 union 解释为 socket 结构而已：

static inline struct socket *SOCKET_I(struct inode *inode)
{
/* 
* container_of(ptr, type, member)宏的作用：
*返回ptr指针所在的结构体；其中ptr为结体体type的变量中member成员的指针；
*将ptr指针转化为char *，然后减去其在结构体中的偏移量，
*得到的是ptr所在的结构体的地址，最后强制转换成type *；
*/
    return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
}

2.1.2 调用协议族的创建方法创建一个套接口，对IPV4来说，就是调用inet_create：

/**
 * 创建一个IPV4的socket
 *  sock:       已经创建的套接口
 *  protocol:   套接口的协议号
 */
static int inet_create(struct socket *sock, int protocol)
{
    struct sock *sk;
    struct list_head *p;
    struct inet_protosw *answer;
    struct inet_sock *inet;
    struct proto *answer_prot;
    unsigned char answer_flags;
    char answer_no_check;
    int err;
/* 
* 初始化套接口状态 
* 插口的初始状态设置成SS_UNCONNECTED，“有连接”模式，既类型为 SOCK_STREAM 的插口必须在建立了连接以后才能使用。
*/
    sock->state = SS_UNCONNECTED;

    answer = NULL;
    rcu_read_lock();
    list_for_each_rcu(p, &inetsw[sock->type]) {/* 根据套接口类型遍历IPV4链表  */
        answer = list_entry(p, struct inet_protosw, list);


        if (protocol == answer->protocol) {/* 比较传输层协议 */
            if (protocol != IPPROTO_IP)
                break;
        } else {

            if (IPPROTO_IP == protocol) {
                protocol = answer->protocol;
                break;
            }
            if (IPPROTO_IP == answer->protocol)
                break;
        }
        answer = NULL;
    }

    err = -ESOCKTNOSUPPORT;
    if (!answer)/* 找不到对应的传输层协议 */
        goto out_rcu_unlock;
    err = -EPERM;
    /* 创建该类型的套接口需要特定能力，而当前进程没有这种能力，则退出 */
    if (answer->capability > 0 && !capable(answer->capability))
        goto out_rcu_unlock;
    err = -EPROTONOSUPPORT;
    if (!protocol)
        goto out_rcu_unlock;

    /* 设置套接口层的接口 */
    sock->ops = answer->ops;
    answer_prot = answer->prot;
    answer_no_check = answer->no_check;
    answer_flags = answer->flags;
    rcu_read_unlock();

    BUG_TRAP(answer_prot->slab != NULL);

    err = -ENOBUFS;
    /* 根据协议族等参数分配传输控制块。 */
    sk = sk_alloc(PF_INET, GFP_KERNEL,
              answer_prot->slab_obj_size,
              answer_prot->slab);
    if (sk == NULL)
        goto out;

    err = 0;
    sk->sk_prot = answer_prot;
    /* 设置是否需要校验和 */
    sk->sk_no_check = answer_no_check;
    /* 是否可以重用地址和端口 */
    if (INET_PROTOSW_REUSE & answer_flags)
        sk->sk_reuse = 1;

    inet = inet_sk(sk);

    if (SOCK_RAW == sock->type) {/* 是原始套接口 */
        inet->num = protocol;/* 设置本地端口为协议号 */
        if (IPPROTO_RAW == protocol)/* 如果是RAW协议，则需要自己构建IP首部 */
            inet->hdrincl = 1;
    }

    if (ipv4_config.no_pmtu_disc)/* 是否支持PMTU */
        inet->pmtudisc = IP_PMTUDISC_DONT;
    else
        inet->pmtudisc = IP_PMTUDISC_WANT;

    inet->id = 0;

    sock_init_data(sock, sk);/* 初始化传输控制块 */
    sk_set_owner(sk, sk->sk_prot->owner);

    /* 在套接口被释放时，进行一些清理工作。 */
    sk->sk_destruct    = inet_sock_destruct;
    /* 设置协议族和协议号 */
    sk->sk_family      = PF_INET;
    sk->sk_protocol    = protocol;
    /* 设置后备队列接收函数。 */
    sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;

    inet->uc_ttl    = -1;
    inet->mc_loop   = 1;
    inet->mc_ttl    = 1;
    inet->mc_index  = 0;
    inet->mc_list   = NULL;

#ifdef INET_REFCNT_DEBUG
    atomic_inc(&inet_sock_nr);
#endif

    if (inet->num) {/* 如果设置了本地端口号 */
        inet->sport = htons(inet->num);/* 设置网络序的本地端口号 */
        sk->sk_prot->hash(sk);/* 将传输控制块加入到静列表中 */
    }

    if (sk->sk_prot->init) {/* 调用传输层的初始化回调，对TCP来说，就是tcp_v4_init_sock。UDP没有设置回调 */
        err = sk->sk_prot->init(sk);
        if (err)
            sk_common_release(sk);
    }
out:
    return err;
out_rcu_unlock:
    rcu_read_unlock();
    goto out;
}

2.1.2.1分配传输控制块sk = sk_alloc()

struct sock *sk_alloc(int family, int priority, int zero_it, kmem_cache_t *slab)
{
    struct sock *sk = NULL;

    if (!slab)/* 如果传输层没有指定缓存分配区，则默认使用sk_cachep */
        slab = sk_cachep;
    /* 在指定的分配区中，用指定的分配参数分配传输控制块  */
    sk = kmem_cache_alloc(slab, priority);
    if (sk) {
        if (zero_it) {/* 需要初始化它 */
            memset(sk, 0,
                   zero_it == 1 ? sizeof(struct sock) : zero_it);
            sk->sk_family = family;
            sock_lock_init(sk);
        }
        /* 释放时需要使用 */
        sk->sk_slab = slab;

        if (security_sk_alloc(sk, family, priority)) {/* 安全审计，如果失败则释放传输层接口 */
            kmem_cache_free(slab, sk);
            sk = NULL;
        }
    }
    return sk;
}

2.1.2.2 inet = inet_sk(sk)
将sock强转为inet_sock，之所以可以强转是因为在分配sock结构体变量时，分配的真实结构体是tcp_sock，而sock、inet_sock、tcp_sock之间均为0处偏移。

2.1.2.3 初始化传输控制块sock_init_data(sock, sk)
本函数主要完成的工作是：
a.初始化sock结构的缓冲区和队列
b.初始化sock结构的一些状态
c.建立socket和sock结构的相互引用关系

2.2 sock_map_fd()代码如下：

/*将套接口与文件描述符绑定。 */
int sock_map_fd(struct socket *sock)
{
    int fd;
    struct qstr this;
    char name[32];

    /* 获得空闲的文件描述符。   */
    fd = get_unused_fd();
    if (fd >= 0) {/* 成功分配文件描述符 */
        struct file *file = get_empty_filp();

        if (!file) {
            put_unused_fd(fd);
            fd = -ENFILE;
            goto out;
        }

        sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
        this.name = name;
        this.len = strlen(name);
        this.hash = SOCK_INODE(sock)->i_ino;

        /*分配文件目录项。       */
        file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
        if (!file->f_dentry) {
            put_filp(file);
            put_unused_fd(fd);
            fd = -ENOMEM;
            goto out;
        }
        file->f_dentry->d_op = &sockfs_dentry_operations;
        d_add(file->f_dentry, SOCK_INODE(sock));
        file->f_vfsmnt = mntget(sock_mnt);
        file->f_mapping = file->f_dentry->d_inode->i_mapping;

        sock->file = file;
        file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops;
        file->f_mode = FMODE_READ | FMODE_WRITE;
        file->f_flags = O_RDWR;
        file->f_pos = 0;
        /* 将文件描述符实例增加到已经打开的文件列表中，完成文件与进程的绑定 */
        fd_install(fd, file);
    }

out:
    return fd;
}

其中fd_install函数如下，只是做了相应指针的改变：

void fastcall fd_install(unsigned int fd, struct file * file)
{
    struct files_struct *files = current->files;
    spin_lock(&files->file_lock);
    if (unlikely(files->fd[fd] != NULL))
        BUG();
    files->fd[fd] = file;
    spin_unlock(&files->file_lock);
}

整体流程图：

重要数据结构：