Разработка ФС

static struct file_system_type ext2_fs_type = {
    .owner        = THIS_MODULE,
    .name        = "ext2",
    .get_sb        = ext2_get_sb, // указатель на функцию возвращающую суперблок
    .kill_sb    = kill_block_super,  // соответственно функция убивающая суперблок
    .fs_flags    = FS_REQUIRES_DEV,
};
static int __init init_ext2_fs(void)
{
    int err = init_ext2_xattr();  // инициализация дополнительных атрибутов... пока не интересно
    if (err)
        return err;
    err = init_inodecache();  // а вот тут начинаются проблемы... не понимаю, что за кеш, а самое главное как из этого кеша вытаскиваются иноды (см. дальше)
    if (err)
        goto out1;
        err = register_filesystem(&ext2_fs_type);  // регистрация файловой системы
    if (err)
        goto out;
    return 0;
// всякие откаты на случай ошибок
out:
    destroy_inodecache();
out1:
    exit_ext2_xattr();
    return err;
}

/**
 *    register_filesystem - register a new filesystem
 *    @fs: the file system structure
 *
 *    Adds the file system passed to the list of file systems the kernel
 *    is aware of for mount and other syscalls. Returns 0 on success,
 *    or a negative errno code on an error.
 *
 *    The &struct file_system_type that is passed is linked into the kernel 
 *    structures and must not be freed until the file system has been
 *    unregistered.
 */
 
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));  // ещет по имени, не добавлена ли уже такая fs
    if (*p)
        res = -EBUSY;
    else
        *p = fs; // добавление ФС в хвост списка (хитрый финт см. функцию  find_filesystem)
    write_unlock(&file_systems_lock);
    return res;
}

struct file_system_type {
    const char *name; //имя
    int fs_flags;
    int (*get_sb) (struct file_system_type *, int,
               const char *, void *, struct vfsmount *);
    void (*kill_sb) (struct super_block *); 
    struct module *owner; //модуль, владеющий ФС, видимо для дебага, или если модуль выгружают, чтобы ФС тоже автоматом выгружалась...
    struct file_system_type * next; // следующая ФС в списке
    struct list_head fs_supers; //заголовок списка суперблоков
//....
// тут ещё какие-то блокировки...
};

// вызывается калбеком откуда-то из кеша...
static void init_once(void *foo)
{
    struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
    // тип инода ext2 для представления в памяти
    rwlock_init(&ei->i_meta_lock);
#ifdef CONFIG_EXT2_FS_XATTR
    init_rwsem(&ei->xattr_sem);
#endif
    mutex_init(&ei->truncate_mutex);
    inode_init_once(&ei->vfs_inode); //забивает инод значениями по умолчанию
}
static int init_inodecache(void)
{
    // пока понятия не имею как работают кеши и с чем их едят... 
    // но тут он, очевидно, создаётся
    ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
                         sizeof(struct ext2_inode_info),
                         0, (SLAB_RECLAIM_ACCOUNT|
                        SLAB_MEM_SPREAD),
                         init_once);
    if (ext2_inode_cachep == NULL)
        return -ENOMEM;
    return 0;
}

/*
 * second extended file system inode data in memory
 */
// часть полей и коментариев пропущено
struct ext2_inode_info {
    __le32    i_data[15];
    __u32    i_flags;
    __u32    i_faddr;
    __u8    i_frag_no;
    __u8    i_frag_size;
    __u16    i_state;
    __u32    i_file_acl;
    __u32    i_dir_acl;
    __u32    i_dtime;
    __u32    i_block_group;
    struct ext2_block_alloc_info *i_block_alloc_info;
    __u32    i_dir_start_lookup;
    rwlock_t i_meta_lock;
    struct mutex truncate_mutex;
    struct inode    vfs_inode; // инод vfs
    struct list_head i_orphan;    /* unlinked but open inodes */
};

struct inode {
    struct hlist_node    i_hash;
    struct list_head    i_list;        /* backing dev IO list */
    struct list_head    i_sb_list;
    struct list_head    i_dentry;
    unsigned long    i_ino;
    atomic_t        i_count;
    unsigned int    i_nlink;
    uid_t        i_uid;
    gid_t        i_gid;
    dev_t        i_rdev;
    unsigned int    i_blkbits;
    u64        i_version;
    loff_t        i_size;
#ifdef __NEED_I_SIZE_ORDERED
    seqcount_t        i_size_seqcount;
#endif
    struct timespec    i_atime;
    struct timespec    i_mtime;
    struct timespec    i_ctime;
    blkcnt_t        i_blocks;
    unsigned short       i_bytes;
    umode_t        i_mode;
    spinlock_t    i_lock;    /* i_blocks, i_bytes, maybe i_size */
    struct mutex    i_mutex;
    struct rw_semaphore    i_alloc_sem;
    const struct inode_operations    *i_op;
    const struct file_operations    *i_fop;    /* former ->i_op->default_file_ops */
    struct super_block    *i_sb;
    struct file_lock    *i_flock;
    struct address_space    *i_mapping;
    struct address_space    i_data;
#ifdef CONFIG_QUOTA
    struct dquot        *i_dquot[MAXQUOTAS];
#endif
    struct list_head    i_devices;
    union {
        struct pipe_inode_info    *i_pipe;
        struct block_device    *i_bdev;
        struct cdev        *i_cdev;
    };
    __u32            i_generation;
#ifdef CONFIG_FSNOTIFY
    __u32            i_fsnotify_mask; /* all events this inode cares about */
    struct hlist_head    i_fsnotify_marks;
#endif
    unsigned long        i_state;
    unsigned long        dirtied_when;    /* jiffies of first dirtying */
    unsigned int        i_flags;
    atomic_t        i_writecount;
#ifdef CONFIG_SECURITY
    void            *i_security;
#endif
#ifdef CONFIG_FS_POSIX_ACL
    struct posix_acl    *i_acl;
    struct posix_acl    *i_default_acl;
#endif
    void            *i_private; /* fs or device private pointer */
};

struct kmem_cache *
kmem_cache_create (const char *name, size_t size, size_t align,
    unsigned long flags, void (*ctor)(void *))
{
    size_t left_over, slab_size, ralign;
    struct kmem_cache *cachep = NULL, *pc;
    gfp_t gfp;
//....
    cachep = kmem_cache_zalloc(&cache_cache, gfp);
    if (!cachep)
        goto oops;
//....
    /*
     * Determine if the slab management is 'on' or 'off' slab.
     * (bootstrapping cannot cope with offslab caches so don't do
     * it too early on. Always use on-slab management when
     * SLAB_NOLEAKTRACE to avoid recursive calls into kmemleak)
     */
    if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init &&
        !(flags & SLAB_NOLEAKTRACE))
        /*
         * Size is large, assume best to place the slab management obj
         * off-slab (should allow better packing of objs).
         */
        flags |= CFLGS_OFF_SLAB;
    size = ALIGN(size, align);
    left_over = calculate_slab_order(cachep, size, align, flags);
    if (!cachep->num) {
        printk(KERN_ERR
               "kmem_cache_create: couldn't create cache %s.\n", name);
        kmem_cache_free(&cache_cache, cachep);
        cachep = NULL;
        goto oops;
    }
    slab_size = ALIGN(cachep->num * sizeof(kmem_bufctl_t)
              + sizeof(struct slab), align);
    /*
     * If the slab has been placed off-slab, and we have enough space then
     * move it on-slab. This is at the expense of any extra colouring.
     */
    if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {
        flags &= ~CFLGS_OFF_SLAB;
        left_over -= slab_size;
    }
    if (flags & CFLGS_OFF_SLAB) {
        /* really off slab. No need for manual alignment */
        slab_size =
            cachep->num * sizeof(kmem_bufctl_t) + sizeof(struct slab);
#ifdef CONFIG_PAGE_POISONING
        /* If we're going to use the generic kernel_map_pages()
         * poisoning, then it's going to smash the contents of
         * the redzone and userword anyhow, so switch them off.
         */
        if (size % PAGE_SIZE == 0 && flags & SLAB_POISON)
            flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
#endif
    }
    cachep->colour_off = cache_line_size();
    /* Offset must be a multiple of the alignment. */
    if (cachep->colour_off < align)
        cachep->colour_off = align;
    cachep->colour = left_over / cachep->colour_off;
    cachep->slab_size = slab_size;
    cachep->flags = flags;
    cachep->gfpflags = 0;
    if (CONFIG_ZONE_DMA_FLAG && (flags & SLAB_CACHE_DMA))
        cachep->gfpflags |= GFP_DMA;
    cachep->buffer_size = size;
    cachep->reciprocal_buffer_size = reciprocal_value(size);
    if (flags & CFLGS_OFF_SLAB) {
        cachep->slabp_cache = kmem_find_general_cachep(slab_size, 0u);
        /*
         * This is a possibility for one of the malloc_sizes caches.
         * But since we go off slab only for object size greater than
         * PAGE_SIZE/8, and malloc_sizes gets created in ascending order,
         * this should not happen at all.
         * But leave a BUG_ON for some lucky dude.
         */
        BUG_ON(ZERO_OR_NULL_PTR(cachep->slabp_cache));
    }
    cachep->ctor = ctor;
    cachep->name = name;
    if (setup_cpu_cache(cachep, gfp)) {
        __kmem_cache_destroy(cachep);
        cachep = NULL;
        goto oops;
    }
    /* cache setup completed, link it into the list */
    list_add(&cachep->next, &cache_chain);
oops:
    if (!cachep && (flags & SLAB_PANIC))
        panic("kmem_cache_create(): failed to create slab `%s'\n",
              name);
    if (slab_is_available()) {
        mutex_unlock(&cache_chain_mutex);
        put_online_cpus();
    }
    return cachep;
}

struct kmem_cache {
    unsigned int size, align;
    unsigned long flags;
    const char *name;
    void (*ctor)(void *);
};