linux-0.98文件系统初始化

[vislee]

概述

微软早期的操作系统是DOS，磁盘操作系统。可见磁盘管理在操作系统中的地位。 而linux中一切兼文件，抽象出的虚拟文件系统更强大。而我一只想搞清楚一切兼文件的真正的意义，一切兼文件是如何实现的，一切兼文件是如何抽象出来的。

代码分析

在main.c文件中，初始化后切换到用户态后，fork出第一个进程先调用了init函数，该函数调用了setup函数初始化文件文件系统挂载根目录。 setup函数是用户态函数，真正的实现是内核kernel/blk_drv/genhd.c文件中的sys_setup函数，在该函数中调用了fs/super.c文件中的mount_root函数挂载根目录。

// 支持的文件系统
static struct file_system_type file_systems[] = {
    {minix_read_super,"minix"},
    {ext_read_super,"ext"},
    {msdos_read_super,"msdos"},
    {proc_read_super,"proc"},
    {NULL,NULL}
};

void mount_root(void)
{
    int i;
    struct file_system_type * fs_type = file_systems;
    struct super_block * p;
    struct inode * mi;

    if (32 != sizeof (struct minix_inode))
        panic("bad i-node size");

        // 初始化全局文件表 
        // fs/file_table.c文件中定义
    for(i=0;i<NR_FILE;i++)
        file_table[i].f_count=0;
    fcntl_init_locks();
    if (MAJOR(ROOT_DEV) == 2) {
        printk("Insert root floppy and press ENTER");
        wait_for_keypress();
    }
        // 初始化超级块数组
    for(p = &super_block[0] ; p < &super_block[NR_SUPER] ; p++) {
        p->s_dev = 0;
        p->s_blocksize = 0;
        p->s_lock = 0;
        p->s_wait = NULL;
        p->s_mounted = p->s_covered = NULL;
    }
    while (fs_type->read_super && fs_type->name) {
        p = read_super(ROOT_DEV,fs_type->name,0,NULL);
        if (p) {
            mi = p->s_mounted;
            mi->i_count += 3 ;  /* NOTE! it is logically used 4 times, not 1 */
            p->s_covered = mi;
            p->s_flags = 0;
            current->pwd = mi;
            current->root = mi;
            return;
        }
        fs_type++;
    }
    panic("Unable to mount root");
}

static struct super_block * read_super(int dev,char *name,int flags,void *data)
{
    struct super_block * s;
    struct file_system_type *type;

    if (!dev)
        return NULL;
    check_disk_change(dev);
    if (s = get_super(dev))
        return s;
    if (!(type = get_fs_type(name))) {
        printk("get fs type failed %s\n",name);
        return NULL;
    }
    for (s = 0+super_block ;; s++) {
        if (s >= NR_SUPER+super_block)
            return NULL;
        if (!s->s_dev)
            break;
    }
    s->s_dev = dev;
    s->s_flags = flags;
        // ext文件系统，ext_read_super函数
    if (!type->read_super(s,data)) {
        s->s_dev = 0;
        return NULL;
    }
    s->s_dev = dev;
    s->s_covered = NULL;
    s->s_rd_only = 0;
    s->s_dirt = 0;
    return s;
}

支持minix ext msdos等文件系统。以ext为例，挂载调用了fs/ext/inode.c文件中ext_read_super函数。 该函数主要功能就是读取磁盘超级块的信息保存到super_block结构体的u.ext_sb中，s_op 指向ext_sops;

include/linux/fs.h文件

struct super_block {
    unsigned short s_dev;
    unsigned long s_blocksize;
    unsigned char s_lock;
    unsigned char s_rd_only;
    unsigned char s_dirt;
    struct super_operations *s_op;
    unsigned long s_flags;
    unsigned long s_magic;
    unsigned long s_time;
    struct inode * s_covered;
    struct inode * s_mounted;
    struct wait_queue * s_wait;
    union {
        struct minix_sb_info minix_sb;
        struct ext_sb_info ext_sb;              // <-----include/linux/ext_fs_sb.h文件
        struct msdos_sb_info msdos_sb;
    } u;
};

fs/ext/inode.c文件

static struct super_operations ext_sops = { 
    ext_read_inode,
    ext_write_inode,
    ext_put_inode,
    ext_put_super,
    ext_write_super,
    ext_statfs
};

// 读取ext文件系统的超级块
struct super_block *ext_read_super(struct super_block *s,void *data)
{
    struct buffer_head *bh;
    struct ext_super_block *es;
    int dev = s->s_dev,block;

    lock_super(s);
    if (!(bh = bread(dev, 1, BLOCK_SIZE))) {
        s->s_dev=0;
        free_super(s);
        printk("bread failed\n");
        return NULL;
    }
    es = (struct ext_super_block *) bh->b_data;
    s->s_blocksize = 1024;
    s->u.ext_sb.s_ninodes = es->s_ninodes;
    s->u.ext_sb.s_nzones = es->s_nzones;
    s->u.ext_sb.s_firstdatazone = es->s_firstdatazone;
    s->u.ext_sb.s_log_zone_size = es->s_log_zone_size;
    s->u.ext_sb.s_max_size = es->s_max_size;
    s->s_magic = es->s_magic;
    s->u.ext_sb.s_firstfreeblocknumber = es->s_firstfreeblock;
    s->u.ext_sb.s_freeblockscount = es->s_freeblockscount;
    s->u.ext_sb.s_firstfreeinodenumber = es->s_firstfreeinode;
    s->u.ext_sb.s_freeinodescount = es->s_freeinodescount;
    brelse(bh);
    if (s->s_magic != EXT_SUPER_MAGIC) {
        s->s_dev = 0;
        free_super(s);
        printk("magic match failed\n");
        return NULL;
    }
    if (!s->u.ext_sb.s_firstfreeblocknumber)
        s->u.ext_sb.s_firstfreeblock = NULL;
    else
        if (!(s->u.ext_sb.s_firstfreeblock = bread(dev,
            s->u.ext_sb.s_firstfreeblocknumber, BLOCK_SIZE))) {
            printk ("ext_read_super: unable to read first free block\n");
            s->s_dev = 0;
            free_super(s);
            return NULL;
        }
    if (!s->u.ext_sb.s_firstfreeinodenumber)
        s->u.ext_sb.s_firstfreeinodeblock = NULL;
    else {
        block = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK;
        if (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
            printk ("ext_read_super: unable to read first free inode block\n");
            brelse(s->u.ext_sb.s_firstfreeblock);
            s->s_dev = 0;
            free_super (s);
            return NULL;
        }
    }
    free_super(s);
    /* set up enough so that it can read an inode */
    s->s_dev = dev;
    s->s_op = &ext_sops;   // 回调函数
        // ext文件系统的根目录inode
    if (!(s->s_mounted = iget(dev,EXT_ROOT_INO))) {
        s->s_dev=0;
        printk("get root inode failed\n");
        return NULL;
    }
    return s;
}

// 回调函数，读取ext文件系统inode
void ext_read_inode(struct inode * inode)
{
    struct buffer_head * bh;
    struct ext_inode * raw_inode;
    int block;

    block = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
    if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
        panic("unable to read i-node block");
    raw_inode = ((struct ext_inode *) bh->b_data) +
        (inode->i_ino-1)%EXT_INODES_PER_BLOCK;
    inode->i_mode = raw_inode->i_mode;
    inode->i_uid = raw_inode->i_uid;
    inode->i_gid = raw_inode->i_gid;
    inode->i_nlink = raw_inode->i_nlinks;
    inode->i_size = raw_inode->i_size;
    inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
    inode->i_blocks = inode->i_blksize = 0;
    if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
        inode->i_rdev = raw_inode->i_zone[0];
    else for (block = 0; block < 12; block++)
        inode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
    brelse(bh);
    inode->i_op = NULL;
    if (S_ISREG(inode->i_mode))
        inode->i_op = &ext_file_inode_operations;
    else if (S_ISDIR(inode->i_mode))
        inode->i_op = &ext_dir_inode_operations;   // fs/ext/dir.c文件中
    else if (S_ISLNK(inode->i_mode))
        inode->i_op = &ext_symlink_inode_operations;
    else if (S_ISCHR(inode->i_mode))
        inode->i_op = &ext_chrdev_inode_operations;
    else if (S_ISBLK(inode->i_mode))
        inode->i_op = &ext_blkdev_inode_operations;
    else if (S_ISFIFO(inode->i_mode)) {
        inode->i_op = &ext_fifo_inode_operations;
        inode->i_pipe = 1;
        PIPE_BASE(*inode) = NULL;
        PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
        PIPE_READ_WAIT(*inode) = PIPE_WRITE_WAIT(*inode) = NULL;
        PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0;
    }
}

然后，调用了fs/inode.c文件中的iget函数获取根目录inode。 该函数先调用get_empty_inode函数从inode_table数组中获取一个空的inode，然后调用read_inode函数填充该空inode。

struct inode * iget(int dev,int nr)
{
    struct inode * inode, * empty;

    if (!dev)
        panic("iget with dev==0");
    empty = get_empty_inode();
        ......

    if (!empty)
        return (NULL);
    inode = empty;
        // 获取对应超级块节点
    if (!(inode->i_sb = get_super(dev))) {
        printk("iget: gouldn't get super-block\n\t");
        iput(inode);
        return NULL;
    }
    inode->i_dev = dev;
    inode->i_ino = nr;
    inode->i_flags = inode->i_sb->s_flags;
        // 调用函数填充inode
    read_inode(inode);
    return inode;
}

static void read_inode(struct inode * inode)
{
    lock_inode(inode);
        // 该s_op 指向的就是ext_sops结构体，对应的read_inode指向的是ext_read_inode函数
        // 然后调用对应文件系统的回调函数，读取inode
    if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
        inode->i_sb->s_op->read_inode(inode);
    unlock_inode(inode);
}

最后，返回到mount_root 函数中，根目录inode赋值给init进程结构体的pwd和root。 在进程中调用open函数，依赖进程的pwd和root，而所有进程又都是init进程的子进程，继承了init进程的pwd和root。

总结

为了支持多种文件系统，linux-0.98的文件系统部分比linux-0.11的复杂了很多。

1. read_super 函数封装了多个文件系统的读取超级块的调用，不同的文件系统调用不同的函数，具体支持的文件系统见file_systems[]数组。
2. iget 函数封装了不同文件系统获取i 节点的调用函数，利用的是super_block的回调函数指针s_op。
3. 不同文件系统不同类型的inode有不同的处理回调函数，利用的是inode的回调函数指针i_op。