EXT文件系统

1、ext2_add_link的执行过程，函数的定义如下：

int ext2_add_link (struct dentry *dentry, struct inode *inode)
{
    struct inode *dir = dentry->d_parent->d_inode;//父节点的inode
    const char *name = dentry->d_name.name;//目录名
    int namelen = dentry->d_name.len;//名字长度
    unsigned chunk_size = ext2_chunk_size(dir);//块大小
    unsigned reclen = EXT2_DIR_REC_LEN(namelen);//4的倍数
    unsigned short rec_len, name_len;
    struct page *page = NULL;
    ext2_dirent * de;
    unsigned long npages = dir_pages(dir);//页数目
    unsigned long n;
    char *kaddr;
    loff_t pos;
    int err;
    for (n = 0; n <= npages; n++) {//遍历每个page
        char *dir_end;
        page = ext2_get_page(dir, n);//从页缓存中读取页
        err = PTR_ERR(page);
        if (IS_ERR(page))
            goto out;
        lock_page(page);
        kaddr = page_address(page);//取到page的线性地址
        dir_end = kaddr + ext2_last_byte(dir, n);//最后一页不满一页
        de = (ext2_dirent *)kaddr;
        kaddr += PAGE_CACHE_SIZE - reclen;
        while ((char *)de <= kaddr) {
            if ((char *)de == dir_end) {        
                name_len = 0;
                rec_len = chunk_size;
                de->rec_len = ext2_rec_len_to_disk(chunk_size);
                de->inode = 0;
                goto got_it;
            }
            if (de->rec_len == 0) {
                ext2_error(dir->i_sb, __FUNCTION__,
                "zero-length directory entry");
                err = -EIO;
                goto out_unlock;
            }
            err = -EEXIST;
            //如果名字匹配
            if (ext2_match (namelen, name, de))
                goto out_unlock;
            name_len = EXT2_DIR_REC_LEN(de->name_len);
            rec_len = ext2_rec_len_from_disk(de->rec_len);
            //取得了一个没有用的目录相
            if (!de->inode && rec_len >= reclen)
                goto got_it;
            //或者说这里是又一个间隔能放下该目录项
            if (rec_len >= name_len + reclen)
                goto got_it;
            //没有找到就跳转到下一个位置
            de = (ext2_dirent *) ((char *) de + rec_len);
        }
        unlock_page(page);
        ext2_put_page(page);
    }
    BUG();
    return -EINVAL;
got_it:
    //pos有两种可能，第一是足够大的间隔前面的目录项，第二是废弃的目录项
    pos = page_offset(page) +(char*)de - (char*)page_address(page);
    //写块
    err = __ext2_write_begin(NULL, page->mapping, pos, rec_len, 0,&page, NULL);
    if (err)
        goto out_unlock;
    //如果是间隔前的目录项
    if (de->inode) {
        //de1为新目录项的开始位置
        ext2_dirent *de1 = (ext2_dirent *) ((char *) de + name_len);
        de1->rec_len = ext2_rec_len_to_disk(rec_len - name_len);
        //修改原目录项指针
        de->rec_len = ext2_rec_len_to_disk(name_len);
        de = de1;
    }
    de->name_len = namelen;
    memcpy(de->name, name, namelen);
    de->inode = cpu_to_le32(inode->i_ino);
    ext2_set_de_type (de, inode);
    err = ext2_commit_chunk(page, pos, rec_len);
    dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
    EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
    //标记为脏准备回写
    mark_inode_dirty(dir);
out_put:
    ext2_put_page(page);
out:
    return err;
out_unlock:
    unlock_page(page);
    goto out_put;
}

大体的过程就是不断的遍历目录项的块，从中查找一个废弃的目录项或者是一个足够大的间隔。具体的执行过程从注释中就很好看懂了。

2、索引节点分配的过程ext2_new_inode，函数的具体定义如下：

//单纯地分配一个inode
struct inode *ext2_new_inode(struct inode *dir, int mode)
{
    struct super_block *sb;
    struct buffer_head *bitmap_bh = NULL;
    struct buffer_head *bh2;
    int group, i;
    ino_t ino = 0;
    struct inode * inode;
    struct ext2_group_desc *gdp;
    struct ext2_super_block *es;
    struct ext2_inode_info *ei;
    struct ext2_sb_info *sbi;
    int err;
    sb = dir->i_sb;
    //分配VFS中的inode
    inode = new_inode(sb);
    if (!inode)
        return ERR_PTR(-ENOMEM);
    ei = EXT2_I(inode);
    sbi = EXT2_SB(sb);
    es = sbi->s_es;
    /*
     * 找到适合的块组
     * 1、find_group_dir强制老式的方式
     * 2、find_group_orlov尽量把目录项对应的普通文件的索引块放在同一个块组
     *    a、以文件系统根root为父目录的目录项应该分散在各个块组
     *    b、该组没有包含太多的目录&&该组有足够多的空闲索引节点&&该组有足够
     *       多的空闲块&&该组有一点小“债”，嵌套目录就应被存放到父目录块组
     *    c、从包含父目录的块组开始选择第一个满足条件的块组，这个条件是：它
     *       的空闲索引节点数比每块组空闲索引节点数的平均值大
     * 3、如果新索引节点不是个目录，则调用find_group_other
     *    a、从包含父目录dir的块组开始，执行快速的对数查找
     *    b、如果该算法没有找到含有空闲索引节点的块组，就从包含父目录dir的
     *       块组开始执行彻底的线性查找
     */
    if (S_ISDIR(mode)) {
        if (test_opt(sb, OLDALLOC))
            group = find_group_dir(sb, dir);
        else
            group = find_group_orlov(sb, dir);
    } else 
        group = find_group_other(sb, dir);
    if (group == -1) {
        err = -ENOSPC;
        goto fail;
    }
    //设置位图，这个操作最多把所有的块组遍历一次
    for (i = 0; i < sbi->s_groups_count; i++) {
        gdp = ext2_get_group_desc(sb, group, &bh2);
        brelse(bitmap_bh);
        bitmap_bh = read_inode_bitmap(sb, group);
        if (!bitmap_bh) {
            err = -EIO;
            goto fail;
        }
        ino = 0;
repeat_in_this_group:
        //找到空闲的位
        ino = ext2_find_next_zero_bit((unsigned long *)bitmap_bh->b_data,
                            EXT2_INODES_PER_GROUP(sb), ino);
        //如果到了最后一个块组，那就回去尝试第一个块组
        if (ino >= EXT2_INODES_PER_GROUP(sb)) {
            if (++group == sbi->s_groups_count)
                group = 0;
            continue;
        }
        if (ext2_set_bit_atomic(sb_bgl_lock(sbi, group),ino, bitmap_bh->b_data)) {
            if (++ino >= EXT2_INODES_PER_GROUP(sb)) {
                if (++group == sbi->s_groups_count)
                    group = 0;
                continue;
            }
            goto repeat_in_this_group;
        }
        goto got;
    }
    err = -ENOSPC;
    goto fail;
got:
    //设置位图的bh为脏的
    mark_buffer_dirty(bitmap_bh);
    if (sb->s_flags & MS_SYNCHRONOUS)
        sync_dirty_buffer(bitmap_bh);
    brelse(bitmap_bh);
    ino += group * EXT2_INODES_PER_GROUP(sb) + 1;
    if (ino < EXT2_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
        ext2_error (sb, "ext2_new_inode",
            "reserved inode or inode > inodes count - "
            "block_group = %d,inode=%lu", group,
            (unsigned long) ino);
        err = -EIO;
        goto fail;
    }
    percpu_counter_add(&sbi->s_freeinodes_counter, -1);
    if (S_ISDIR(mode))
        percpu_counter_inc(&sbi->s_dirs_counter);
    spin_lock(sb_bgl_lock(sbi, group));
    gdp->bg_free_inodes_count =cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
    if (S_ISDIR(mode)) {
        if (sbi->s_debts[group] < 255)
            sbi->s_debts[group]++;
        gdp->bg_used_dirs_count =
            cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
    } else {
        if (sbi->s_debts[group])
            sbi->s_debts[group]--;
    }
    spin_unlock(sb_bgl_lock(sbi, group));
    sb->s_dirt = 1;
    mark_buffer_dirty(bh2);
    inode->i_uid = current->fsuid;
    if (test_opt (sb, GRPID))
        inode->i_gid = dir->i_gid;
    else if (dir->i_mode & S_ISGID) {
        inode->i_gid = dir->i_gid;
        if (S_ISDIR(mode))
            mode |= S_ISGID;
    } else
        inode->i_gid = current->fsgid;
    //设置inode的属性
    inode->i_mode = mode;
    inode->i_ino = ino;
    inode->i_blocks = 0;
    inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
    memset(ei->i_data, 0, sizeof(ei->i_data));
    ei->i_flags = EXT2_I(dir)->i_flags & ~EXT2_BTREE_FL;
    if (S_ISLNK(mode))
        ei->i_flags &= ~(EXT2_IMMUTABLE_FL|EXT2_APPEND_FL);
    if (!S_ISDIR(mode))
        ei->i_flags &= ~EXT2_DIRSYNC_FL;
    ei->i_faddr = 0;
    ei->i_frag_no = 0;
    ei->i_frag_size = 0;
    ei->i_file_acl = 0;
    ei->i_dir_acl = 0;
    ei->i_dtime = 0;
    ei->i_block_alloc_info = NULL;
    ei->i_block_group = group;
    ei->i_dir_start_lookup = 0;
    ei->i_state = EXT2_STATE_NEW;
    ext2_set_inode_flags(inode);
    spin_lock(&sbi->s_next_gen_lock);
    inode->i_generation = sbi->s_next_generation++;
    spin_unlock(&sbi->s_next_gen_lock);
    insert_inode_hash(inode);
    if (DQUOT_ALLOC_INODE(inode)) {
        err = -EDQUOT;
        goto fail_drop;
    }
    err = ext2_init_acl(inode, dir);
    if (err)
        goto fail_free_drop;
    err = ext2_init_security(inode,dir);
    if (err)
        goto fail_free_drop;
    mark_inode_dirty(inode);
    ext2_debug("allocating inode %lu\n", inode->i_ino);
    ext2_preread_inode(inode);
    return inode;
fail_free_drop:
    DQUOT_FREE_INODE(inode);
fail_drop:
    DQUOT_DROP(inode);
    inode->i_flags |= S_NOQUOTA;
    inode->i_nlink = 0;
    iput(inode);
    return ERR_PTR(err);
fail:
    make_bad_inode(inode);
    iput(inode);
    return ERR_PTR(err);
}

这个函数总的过程还是很简单的，先分配VFS中的索引节点（这是最容易的事情了），然后找到适合的块组，从该块组的位图中找到空闲位。初始化索引节点的一些属性。最后把他们都标记成脏的，以便被写回硬盘。关于找块组的过程还是挺有意思的。