Linux网络协议栈 -- socket创建(3)

五、初始化 sk
 
分配完成 sk 后,另一个重要的功能就是初始化它,sk 的成员相当复杂,其主要的初始化工作是在函数 sock_init_data()中完成的: 


void sock_init_data(struct socket *sock, struct sock *sk) 


        /*  初始化其三个队列 */ 
        skb_queue_head_init(&sk->sk_receive_queue); 
        skb_queue_head_init(&sk->sk_write_queue); 
        skb_queue_head_init(&sk->sk_error_queue); 
 
        sk->sk_send_head        =        NULL; 
         /*  初始化数据包发送定时器 */ 
        init_timer(&sk->sk_timer); 
         
        sk->sk_allocation        =        GFP_KERNEL; 
        sk->sk_rcvbuf                =        sysctl_rmem_default; 
        sk->sk_sndbuf                =        sysctl_wmem_default; 
        sk->sk_state                =        TCP_CLOSE; 
        /*  指向对应的 socket 结构 */ 
        sk->sk_socket                =        sock; 
 
        sock_set_flag(sk, SOCK_ZAPPED); 
 
        if(sock) 
        { 
                sk->sk_type        =        sock->type; 
                sk->sk_sleep        =        &sock->wait; 
                /*  回指对应的 scok 结构 */ 
                sock->sk        =        sk; 
        } else 
                sk->sk_sleep        =        NULL; 
 
        rwlock_init(&sk->sk_dst_lock); 
        rwlock_init(&sk->sk_callback_lock); 
 
        sk->sk_state_change        =        sock_def_wakeup; 
        sk->sk_data_ready        =        sock_def_readable; 
        sk->sk_write_space        =        sock_def_write_space; 
        sk->sk_error_report         =        sock_def_error_report; 
        sk->sk_destruct                =        sock_def_destruct; 
 
        sk->sk_sndmsg_page        =        NULL; 
        sk->sk_sndmsg_off        =        0; 
 
        sk->sk_peercred.pid         =        0; 
        sk->sk_peercred.uid        =        -1; 
        sk->sk_peercred.gid        =        -1; 
        sk->sk_write_pending        =        0; 
        sk->sk_rcvlowat                =        1; 
        sk->sk_rcvtimeo                =        MAX_SCHEDULE_TIMEOUT; 
        sk->sk_sndtimeo                =        MAX_SCHEDULE_TIMEOUT; 
 
        sk->sk_stamp.tv_sec     = -1L; 
        sk->sk_stamp.tv_usec    = -1L; 
         atomic_set(&sk->sk_refcnt, 1); 
}
 
sock 结构中,有三个重要的双向队列,分别是 sk_receive_queue、sk_write_queue和 sk_error_queue。从它们的名字就可以看出来其作用了。 队列并非采用通用的 list_head 来维护,而是使用 skb_buffer 队列: 


struct sk_buff_head { 

        /* These two members must be first. */ 
        struct sk_buff        *next; 
        struct sk_buff        *prev; 
 
        __u32                qlen; 
        spinlock_t        lock; 
};
 
这样,队列中指向的每一个 skb_buffer,就是一个数据包,分别是接收、发送和投递错误。 
 
剩余的就是初始化其它成员变量了。后面再来专门分析这些成员的作用。 
 
inet_create 函数中,除了初始化 sk 成员的值,还有一部份代码,是初始化一个 inet的东东: 
        inet = inet_sk(sk); 
        inet->uc_ttl        = -1; 
        inet->mc_loop        = 1; 
        inet->mc_ttl        = 1; 
        inet->mc_index        = 0; 
        inet->mc_list        = NULL;[/code] 
 
inet 是一个 struct inet_sock 结构类型,来看它的定义: 


struct inet_sock { 

        /* sk and pinet6 has to be the first two members of inet_sock */ 
        struct sock                sk; 
               …… 
}
只留意它的第一个成员就足够了。 
 

我们说 sock 是面向用户态调用,而 sk 是面向内核驱动调用的,那 sk 是如何与协议栈交互的呢?对于每一个类型的协议,为了与 sk 联系起来,都定义了一个 struct XXX_sock 结构,XXX是协议名,例如:

 

struct tcp_sock { 
        /* inet_sock has to be the first member of tcp_sock */ 
        struct inet_sock        inet; 
        int        tcp_header_len;        /* Bytes of tcp header to send                */ 
        …… 
}  
struct udp_sock { 
        /* inet_sock has to be the first member */ 
        struct inet_sock inet; 
        int                 pending;        /* Any pending frames ? */ 
        unsigned int         corkflag;        /* Cork is required */ 
          __u16                 encap_type;        /* Is this an Encapsulation socket? */ 
        /* 
         * Following member retains the infomation to create a UDP header 
         * when the socket is uncorked. 
         */ 
        __u16                 len;                /* total length of pending frames */ 
}; 
 
struct raw_sock { 
        /* inet_sock has to be the first member */ 
        struct inet_sock   inet; 
        struct icmp_filter filter; 
};
 
很明显,它们的结构定构是“af_inet一般属性+自己的私有属性”,因为它们的第一个成员总是 inet。  
 
呵呵,现在回头来照一下起初在 af_inet.c 中,封装协议注册的时候,size成员,对于 tcp 而言: 
.obj_size                = sizeof(struct tcp_sock), 
其它协议类似。 
 
以 obj_size 来确定每个 slab 缓存项分配的大小,所以,我们就可说,每次申请分配的,实际上是一个 struct XXX_sock 结构大小的结构。因为都是定义于上层结构的第一个成员,可以使用强制类型转换来使用这块分配的内存空间。例如: 


inet = inet_sk(sk); 

 
static inline struct inet_sock *inet_sk(const struct sock *sk) 

        return (struct inet_sock *)sk; 

 
struct tcp_sock *tp = tcp_sk(sk); 
 
static inline struct tcp_sock *tcp_sk(const struct sock *sk) 

        return (struct tcp_sock *)sk; 
}
 
OK,inet_create()运行完,一个 socket 套接字基本上就创建完毕了,剩下的就是与文件系统挂钩,回到最初的 sys_socket()函数中来,它在调用完 sock_create()后,紧接着调用 sock_map_fd()函数: 

int sock_map_fd(struct socket *sock) 

        int fd; 
        struct qstr this; 
        char name[32]; 
 
        /* 
         *        Find a file descriptor suitable for return to the user.  
         */ 
 
        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; 
}
 
这个函数的核心思想,在一开始,就已经分析过了。从进程的角度来讲,一个socket 套接字就是一个特殊的,已打开的文件。前面分配好一个 socket  后,这里要做的就是将它与文件系统拉上亲戚关系。首先获取一个空闲的文件描述符号和 file 结构。然后在文件系统中分配一个目录项(d_alloc),使  其指向已经分配的 inode 节点(d_add),然后把其目录项挂在 sockfs 文件系统的根目录之下。并且把目录项的指针 d_op设置成指向 sockfs_dentry_operati,这个数据结构通过函数指针提供他与文件路径有关的操作: 


static struct dentry_operations sockfs_dentry_operations = { 

        .d_delete =        sockfs_delete_dentry, 
};
 
最后一步,就是将 file 结构中的 f_op 和 sock 结构中的 i_fop 都指向 socket_file_ops,它是一个函数指针集,指向了 socket面向文件系统的用户态调用的一些接口函数: 


static struct file_operations socket_file_ops = { 

        .owner =        THIS_MODULE, 
        .llseek =        no_llseek, 
        .aio_read =        sock_aio_read, 
        .aio_write =        sock_aio_write, 
        .poll =                sock_poll, 
        .unlocked_ioctl = sock_ioctl, 
        .mmap =                sock_mmap, 
        .open =                sock_no_open,        /* special open code to disallow open via /proc */ 
        .release =        sock_close, 
        .fasync =        sock_fasync, 
        .readv =        sock_readv, 
        .writev =        sock_writev, 
        .sendpage =        sock_sendpage 
};
 

OK,到这里,整个 socket 套接字的创建工作,就宣告完成了。

写到这里,可以为 socket 的创建下一个小结了: 
1、所谓创建socket,对内核而言,最重要的工作就是分配 sock 与 sk; 
2、 sock 面向上层系统调用,主要是与文件系统交互。通过进程的 current 指针的 files,结合创建 socket时返回的文件描符述,可以找到内  核中对应的 struct file,再根据 file的 f_dentry可以找到对应的目录项,而目录项 struct dentry 中,有 d_inode 指针,指向与 sock 封装在一起的 inode。sock 又与 sk指针互指,一一对应。在这串结构中,有两个重要的函数集  指针,一个是文件系统 struct file 中的f_op指针,它指向了,对应的用户态调用的read,write等操调用,但不支持open,另一个是struct socket结构,即 sock 的ops 指针,它在 inet_create()中被置为 sock->ops = answer->ops; 指向具体协议类型的 ops;例如,inet_stream_ops、inet_dgram_ops 或者是 inet_sockraw_ops 等等。它用来支持上层的 socket 的其它 API 调用。 
3、sk 面向内核协议栈,协议栈与它的接口数据结构是 struct protoname_sock,该结构中包含了一般性的 inet 结构和自己的私有成员,struct inet_sock 的第一个成员就是一个 sk 指针,而分配的 sk,实际上空间大小是 struct protoname_sock,所以,这三者可以通过强制类型转换来获取需要的指针。  

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值