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

static int ext2_get_sb(struct file_system_type *fs_type,
    int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
    return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
}

int get_sb_bdev(struct file_system_type *fs_type,
    int flags, const char *dev_name, void *data,
    int (*fill_super)(struct super_block *, void *, int),
    struct vfsmount *mnt)
{
    struct block_device *bdev;
    struct super_block *s;
    fmode_t mode = FMODE_READ;
    int error = 0;
    if (!(flags & MS_RDONLY)) //если не ридонли, то разрешаем запись
        mode |= FMODE_WRITE;
    bdev = open_bdev_exclusive(dev_name, mode, fs_type);  //открываем блочное устройство
    if (IS_ERR(bdev))  // ошибка при ахтунге
        return PTR_ERR(bdev); 
    /*
     * once the super is inserted into the list by sget, s_umount
     * will protect the lockfs code from trying to start a snapshot
     * while we are mounting
     */
    mutex_lock(&bdev->bd_fsfreeze_mutex);
    if (bdev->bd_fsfreeze_count > 0) {  // не очень понятно, что мы тут проверяем.. что за замороженные процессы...
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        error = -EBUSY;
        goto error_bdev;
    }
    s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);  // собственно ищет и создаёт суперблок
    mutex_unlock(&bdev->bd_fsfreeze_mutex);
    if (IS_ERR(s))
        goto error_s;
    // не понятно, кто бы мог это установить... похоже где-то в тёмной части c test в sget
    if (s->s_root) {
        if ((flags ^ s->s_flags) & MS_RDONLY) {
            deactivate_locked_super(s);
            error = -EBUSY;
            goto error_bdev;
        }
        /*
         * s_umount nests inside bd_mutex during
         * __invalidate_device().  close_bdev_exclusive()
         * acquires bd_mutex and can't be called under
         * s_umount.  Drop s_umount temporarily.  This is safe
         * as we're holding an active reference.
         */
        up_write(&s->s_umount);
        close_bdev_exclusive(bdev, mode);
        down_write(&s->s_umount);
    } else {
        char b[BDEVNAME_SIZE];
        s->s_flags = flags; // устанавливаем флаги
        s->s_mode = mode; // режим
        strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));  // заменяем имя
        sb_set_blocksize(s, block_size(bdev));  // устанавливаем размер блока
        error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);  //!!!калл-бек в модуль ФС
        if (error) {
            deactivate_locked_super(s);
            goto error;
        }
        s->s_flags |= MS_ACTIVE;
        bdev->bd_super = s;
    }
    simple_set_mnt(mnt, s);
    return 0;
error_s:
    error = PTR_ERR(s);
error_bdev:
    close_bdev_exclusive(bdev, mode);
error:
    return error;
}

/**
 *    sget    -    find or create a superblock
 *    @type:    filesystem type superblock should belong to
 *    @test:    comparison callback
 *    @set:    setup callback
 *    @data:    argument to each of them
 */
struct super_block *sget(struct file_system_type *type,
            int (*test)(struct super_block *,void *),
            int (*set)(struct super_block *,void *),
            void *data)
{
    struct super_block *s = NULL;
    struct super_block *old;
    int err;
retry:
    spin_lock(&sb_lock);
    if (test) {// если нам передали указатель на функцию тестирования суперблока, то проходим по всем спискам суперблоков для ФС и перепроверяем их(если не ошибыюсь)
        list_for_each_entry(old, &type->fs_supers, s_instances) {
            if (!test(old, data))
                continue;
            if (!grab_super(old))
                goto retry;
            if (s) {
                up_write(&s->s_umount);
                destroy_super(s);
                s = NULL;
            }
            down_write(&old->s_umount);
            if (unlikely(!(old->s_flags & MS_BORN))) {
                deactivate_locked_super(old);
                goto retry;
            }
            return old; 
        }
    }
    if (!s) { // если указатель на суперблок ==нулю(а это скорей всего так), то пытаемся его создать
        spin_unlock(&sb_lock);
        s = alloc_super(type);
        if (!s)
            return ERR_PTR(-ENOMEM);
        goto retry;
    }
        
    err = set(s, data); // калл-бек
    if (err) { 
        spin_unlock(&sb_lock);
        up_write(&s->s_umount);
        destroy_super(s);
        return ERR_PTR(err);
    }
    s->s_type = type;  // начинаем заполнение структуры... устанавливаем тип ФС
    strlcpy(s->s_id, type->name, sizeof(s->s_id));  //устанавливаем ID ФС суперблока
    list_add_tail(&s->s_list, &super_blocks);  //добавляет новый суперблок в конец списка СБ
    list_add(&s->s_instances, &type->fs_supers);  // добавляет суперблок в список суперблоков ФС
    spin_unlock(&sb_lock);  
    get_filesystem(type);  //!!! похоже подгружает модуль для ФС (поправте меня)!!!
    return s;
}

static int ext2_fill_super(struct super_block *sb, void *data, int silent)
// sb - структура суперблока, которую заполняем
// data - данные, которые передали транзитом (А кстати откуда эти данные пришли и что это такое?) 
//     судя по всему это опции монтирования в виде простой текстовой строки...
{
    struct buffer_head * bh;    // заголовок буфера чтения
    struct ext2_sb_info * sbi;    // указатель на эти данные, специфические для ФС будет хранится в суперблоке
    struct ext2_super_block * es;    // структура суперблока, так, как она хранится на диске
// ...
    if (blocksize != BLOCK_SIZE) { // перещёт смешения, если суперблок находится не на границе блока устройства
        logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
        offset = (sb_block*BLOCK_SIZE) % blocksize;
    } else {
        logic_sb_block = sb_block; 
    }
    if (!(bh = sb_bread(sb, logic_sb_block))) { // собственно создание и чтение в буффер суперблока
        ext2_msg(sb, KERN_ERR, "error: unable to read superblock");
        goto failed_sbi;
    }
// ...
// потом уставливаем дефолтные значения
// правим их в зависимости от опций монтирования
// проверка, не попытались ли мы использовать какие-то неподдерживаемые опции
// копирование разнообразных параметров в sbi
// ...
// что-то про группы, фрагменты итп... в общем в этом разбираться бесполезно, 
// пока более-менее не освоюсь в структуре ФС
// ...
// !а вот это очень важно!
    sb->s_op = &ext2_sops; // установка структуры-списка операций над ФС
    sb->s_export_op = &ext2_export_ops;  // не столь важные операции
    sb->s_xattr = ext2_xattr_handlers;  // операции над доп. атрибутами
// ...
    root = ext2_iget(sb, EXT2_ROOT_INO);  // чтение инода корня ФС
// ...
    sb->s_root = d_alloc_root(root);
// ...
    ext2_write_super(sb);  // не совсем понял, зачем нам записывать суперблок после того, как мы его загрузили
    return 0;
// ... обработка ошибок
}

static const struct super_operations ext2_sops = {
    .alloc_inode     = ext2_alloc_inode,  // выделяем инод в кеше
    .destroy_inode   = ext2_destroy_inode,  // соответственно уничтожаем инод
    .write_inode     = ext2_write_inode,  // сохранение инода на диск
    .evict_inode     = ext2_evict_inode,  // пока не понял (???) может удаление
    .put_super       = ext2_put_super,    // освобождение суперблока
    .write_super     = ext2_write_super, // запись суперблока на диск
    .sync_fs         = ext2_sync_fs,   // записывает грязный суперблок надиск (вычитал в книжке, сильно в этом сомневаюсь)
    .statfs          = ext2_statfs,   // получение статистики ФС
    .remount_fs      = ext2_remount,  // перемонтирование ФС
    .show_options    = ext2_show_options,  // тоже пока загадка
#ifdef CONFIG_QUOTA
    .quota_read      = ext2_quota_read,
    .quota_write     = ext2_quota_write,
#endif
};

static unsigned long get_sb_block(void **data)
{
    unsigned long     sb_block;
    char         *options = (char *) *data;
    if (!options || strncmp(options, "sb=", 3) != 0)
        return 1;    /* Default location */
    options += 3;
    sb_block = simple_strtoul(options, &options, 0);
    if (*options && *options != ',') {
        printk("EXT2-fs: Invalid sb specification: %s\n",
               (char *) *data);
        return 1;
    }
    if (*options == ',')
        options++;
    *data = (void *) options;
    return sb_block;
}

struct super_block {
    struct list_head    s_list;        /* Keep this first */  // заголовок списка суперблоков
    dev_t            s_dev;        /* search index; _not_ kdev_t */ // пока не ясно что это
    unsigned char        s_dirt;  // флаг грязности инода
    unsigned char        s_blocksize_bits; // ???
    unsigned long        s_blocksize; // размер блока данных
    loff_t            s_maxbytes;    /* Max file size */
    struct file_system_type    *s_type;  // указатель на тип ФС ()
    const struct super_operations    *s_op;  // список доступных операций
    const struct dquot_operations    *dq_op;  // операции связанные с квотами
    const struct quotactl_ops    *s_qcop;  // в ту же степь
    const struct export_operations *s_export_op;  //ещё какие-то операции
    unsigned long        s_flags;  // флаги какие-то
    unsigned long        s_magic; // что за магическое число до сих пор не понимаю... (похоже или UUID, или уникальный для каждого типа ФС)
    struct dentry        *s_root;  // указатель на структуру связанную с корнем
    struct rw_semaphore    s_umount; // видимо блокировка отмонтирования при работе с ФС
    struct mutex        s_lock; // а это бокировка на монопольный доступ к ФС
    int            s_count; // ???
    atomic_t        s_active; // ???
#ifdef CONFIG_SECURITY
    void                    *s_security;
#endif
    const struct xattr_handler **s_xattr;  // тоже операции/обработчики чего-то связанного с xattr'ами 
    struct list_head    s_inodes;    /* all inodes */
    struct hlist_head    s_anon;        /* anonymous dentries for (nfs) exporting */
#ifdef CONFIG_SMP
    struct list_head __percpu *s_files;
#else
    struct list_head    s_files;  // список открытых файлов 
#endif
    /* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
    struct list_head    s_dentry_lru;    /* unused dentry lru */
    int            s_nr_dentry_unused;    /* # of dentry on lru */
    struct block_device    *s_bdev;  // блочное устройство, ассоциированное с ФС
    struct backing_dev_info *s_bdi;  // ???
    struct mtd_info        *s_mtd; // ???
    struct list_head    s_instances; // ???
    struct quota_info    s_dquot;    /* Diskquota specific options */
    int            s_frozen; // ???
    wait_queue_head_t    s_wait_unfrozen; // ???
    char s_id[32];                /* Informational name */
    void             *s_fs_info;    /* Filesystem private info */
    fmode_t            s_mode; // ???
    /* Granularity of c/m/atime in ns.
       Cannot be worse than a second */
    u32           s_time_gran; // надо понять, что такое грунул[ярность/ирование]
    /*
     * The next field is for VFS *only*. No filesystems have any business
     * even looking at it. You had been warned.
     */
    struct mutex s_vfs_rename_mutex;    /* Kludge */ 
    /*
     * Filesystem subtype.  If non-empty the filesystem type field
     * in /proc/mounts will be "type.subtype"
     */
    char *s_subtype;
    /*
     * Saved mount options for lazy filesystems using
     * generic_show_options()
     */
    char *s_options;  // опа на...
};

[63516.350370] EXT3-fs (loop0): error: no journal found. mounting ext3 over ext2?
[63531.752337] EXT4-fs (loop0): mounted filesystem without journal. Opts: (null)
[64834.130508] EXT2-fs (loop0): warning: mounting ext3 filesystem as ext2
[64986.218178] EXT3-fs: barriers not enabled
[64986.218209] kjournald starting.  Commit interval 5 seconds
[64986.218242] EXT3-fs (loop0): using internal journal
[64986.218246] EXT3-fs (loop0): mounted filesystem with writeback data mode
[65001.334499] EXT4-fs (loop0): mounted filesystem with ordered data mode. Opts: (null)
[65775.969452] EXT2-fs (loop0): error: couldn't mount because of unsupported optional features (240)
[65782.602635] EXT3-fs (loop0): error: couldn't mount because of unsupported optional features (240)