《追踪linux tcp/ip代码运行》--网络文件系统的初始化

 《追踪linux tcp/ip代码运行》这本书有些地方作者写的比较简单，需要对linux相关模块实现原理了解，否则不太好理解。估计是由于篇幅有限，作者只能点到为止。
  最近把linux文件系统相关的学习了一下，感觉收获还是比较大。推荐两本新手学习内核代码比较好的书籍《linux内核情景分析》和《独辟蹊径品内核》，当然任何书都不是完美的，这两本书只能说对我这种菜鸟帮助非常大！学习代码时首先不要细扣，先了解代码大致的结构和流程即可，后续如果需要可以深入研究。linux代码错综复杂，当开始一味追求全部搞明白的时候，估计就会失去兴趣了，难免不抓狂。我反正是这样子！^_^

那么，网络文件系统是如何初始化的？
初始化的入口在下面的函数：

core_initcall(sock_init); /* early initcall */
#define core_initcall(fn) __define_initcall("1",fn,1)
#define __define_initcall(level,fn,id) \
static initcall_t __initcall_##fn##id __used \
__attribute__((__section__(".initcall" level ".init"))) = fn

前面写过一篇模块初始化函数module_init()，core_initcall(fn)和module_init函数类似，都是在编译时将定义的函数fn放到指定初始化的section中(系统初始化时即会执行这些函数)。
上面的宏即定义了一个__initcall_sock_init_1变量，这个变量是initcall_t 类型，typedef int (*initcall_t)(void);它是一个函数指针，即是一个函数，而这个变量被赋值为fn，即sock_init。


那么继续看这个函数：

static int __init sock_init(void)
{
/*
*      Initialize sock SLAB cache.
*/


sk_init();


/*
*      Initialize skbuff SLAB cache
*/
skb_init();


/*
*      Initialize the protocols module.
*/


init_inodecache();
register_filesystem(&sock_fs_type);//注册网络文件系统
sock_mnt = kern_mount(&sock_fs_type);//“挂载”网络文件系统


/* The real protocol initialization is performed in later initcalls.
*/


#ifdef CONFIG_NETFILTER
netfilter_init();
#endif


return 0;
}

主要看网络文件系统的注册和挂载：
任何文件系统在mount时首先都会去注册该文件系统，linux内核将所有挂载的文件系统都注册到全局变量file_systems中（依靠成员next组成单链表）：
static struct file_system_type *file_systems;

int register_filesystem(struct file_system_type * fs)
{
int res = 0;
struct file_system_type ** p;


BUG_ON(strchr(fs->name, '.'));
if (fs->next)
return -EBUSY;
INIT_LIST_HEAD(&fs->fs_supers);
write_lock(&file_systems_lock);
p = find_filesystem(fs->name, strlen(fs->name));
if (*p)
res = -EBUSY;//该文件系统已经注册
else
*p = fs;//未注册，则在链表结尾将该文件系统链接上去
write_unlock(&file_systems_lock);
return res;
}

static struct file_system_type **find_filesystem(const char *name, unsigned len)
{
struct file_system_type **p;
for (p=&file_systems; *p; p=&(*p)->next)//在全局链表中按照文件系统的名字找该文件系统是否已经注册
if (strlen((*p)->name) == len &&
   strncmp((*p)->name, name, len) == 0)
break;
return p;
}

网络文件系统利用kern_mount函数进行挂载，具体调用流程为：

#define kern_mount(type) kern_mount_data(type, NULL)
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
{
return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
}

struct vfsmount *
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
{
struct vfsmount *mnt;
char *secdata = NULL;
int error;

if (!type)
return ERR_PTR(-ENODEV);

error = -ENOMEM;
mnt = alloc_vfsmnt(name);//每个文件系统挂载都会有一个对应的vfsmount结构，结构主要包含了挂载点、父文件系统挂载点等，后续代码中会有对成员的填充
if (!mnt)
goto out;
      
        省略若干代码
 error = type->get_sb(type, flags, name, data, mnt);//生成vfs对应的super_block结构，调用的函数为sockfs_get_sb
if (error < 0)
goto out_free_secdata;
BUG_ON(!mnt->mnt_sb);
省略若干代码
mnt->mnt_mountpoint = mnt->mnt_root;
mnt->mnt_parent = mnt;
up_write(&mnt->mnt_sb->s_umount);

}

static struct file_system_type sock_fs_type = {
.name = "sockfs",
.get_sb = sockfs_get_sb,
.kill_sb = kill_anon_super,
};

网络文件系统对应的file_system_type结构中的get_sb函数为 sockfs_get_sb，这个函数会对网络文件系统的super_block、inode、dentry结构进行构建填充。。

static int sockfs_get_sb(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data,
struct vfsmount *mnt)
{
return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,
    mnt);
}
int get_sb_pseudo(struct file_system_type *fs_type, char *name,
const struct super_operations *ops, unsigned long magic,
struct vfsmount *mnt)
{
struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
struct dentry *dentry;
struct inode *root;
struct qstr d_name = {.name = name, .len = strlen(name)};

if (IS_ERR(s))
return PTR_ERR(s);

s->s_flags = MS_NOUSER;
s->s_maxbytes = ~0ULL;
s->s_blocksize = 1024;
s->s_blocksize_bits = 10;
s->s_magic = magic;
s->s_op = ops ? ops : &simple_super_operations;
s->s_time_gran = 1;
root = new_inode(s);//调用sock_alloc_inode创建vfs的根inode节点


if (!root)
goto Enomem;
/*
* since this is the first inode, make it number 1. New inodes created
* after this must take care not to collide with it (by passing
* max_reserved of 1 to iunique).
*/
root->i_ino = 1;
root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
root->i_uid = root->i_gid = 0;
root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
dentry = d_alloc(NULL, &d_name);
if (!dentry) {
iput(root);
goto Enomem;
}
dentry->d_sb = s;
dentry->d_parent = dentry;
d_instantiate(dentry, root);
s->s_root = dentry;
s->s_flags |= MS_ACTIVE;
return simple_set_mnt(mnt, s);
Enomem:
up_write(&s->s_umount);
deactivate_super(s);
return -ENOMEM;
}

static struct super_operations sockfs_ops = {
.alloc_inode =sock_alloc_inode,
.destroy_inode =sock_destroy_inode,
.statfs = simple_statfs,
};

static struct inode *sock_alloc_inode(struct super_block *sb)
{
struct socket_alloc *ei;//在网络文件系统中分配inode节点时，会有一个新的结构体socket_alloc，这个结构体包含了一个inode结构和一个socket结构，到此为止，我们终于将网络文件系统和socket这个结构体关联上了。
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;
}

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

在上述sock_alloc_inode中，我们看到了socket结构体的分配是与inode节点的分配息息相关的。