挂载 VFS 错误：挂载：/fwd：错误的 fs 类型、错误的选项、/dev/loop0 上的超级块错误、缺少代码页或帮助程序或其他错误

问题描述

我正在尝试在 Linux 中挂载 VFS，但它给了我这个错误

挂载：/fwd：错误的 fs 类型、错误的选项、/dev/loop0 上的超级块错误、缺少代码页或帮助程序或其他错误。

看起来它给我的错误是我弄乱了我的超级块结构。

sudo demsg output

[25665.303994] 坏幻数

[25665.303998] 读取 buffer_head 时出错

[25665.303998] 坏块大小

我安装了 abc# mount test_###.ko /fwd 模块完整代码如下

    #include <linux/init.h>
    #include <linux/fs.h>
    #include <linux/pagemap.h>
    #include <linux/highmem.h>
    #include <linux/time.h>
    #include <linux/string.h>
    #include <linux/backing-dev.h>
    #include <linux/ramfs.h>
    #include <linux/sched.h>
    #include <linux/parser.h>
    #include <linux/magic.h>
    #include <linux/slab.h>
    #include <asm/uaccess.h>
    #include <linux/proc_fs.h>
    #include <linux/pci.h>

    #define RAMFS_DEFAULT_MODE  0755


    /*
    int pci_mmap_fits(struct pci_dev *pdev,int resno,struct vm_area_struct *vma,enum pci_mmap_api mmap_api);*/
    extern ssize_t generic_file_splice_write(struct pipe_inode_info *,struct file *,loff_t *,size_t,unsigned int);
    extern ssize_t do_sync_write(struct file *filp,const char __user *buf,size_t len,loff_t *ppos);
    const struct address_space_operations ramfs_aops = {
        .readpage   = simple_readpage,.write_begin    = simple_write_begin,.write_end  = simple_write_end,};

    const struct file_operations ramfs_file_operations = {

        .read   = generic_read_dir,.mmap       = generic_file_mmap,.fsync      = noop_fsync,.llseek     = generic_file_llseek,};

    const struct inode_operations ramfs_file_inode_operations = {
        .setattr    = simple_setattr,.getattr    = simple_getattr,};

    static const struct super_operations ramfs_ops;
    static const struct inode_operations ramfs_dir_inode_operations;

    static struct backing_dev_info ramfs_backing_dev_info = {
        .name       = "ramfs",.ra_pages   = 0,/* No readahead */
        .capabilities   = NOMMU_MAP_DIRECT | NOMMU_MAP_COPY |
                      NOMMU_MAP_READ     | NOMMU_MAP_EXEC    | NOMMU_MAP_WRITE,};
    //*************************************************Functons*************************************************************

    enum pci_mmap_api {
        PCI_MMAP_SYSFS,//mmap on /sys/bus/pci/devices/<BDF>/resource<N>
        PCI_MMAP_PROCFS  //mmap on /proc/bus/pci/<BDF>
    };
    int pci_mmap_fits(struct pci_dev *pdev,struct vm_area_struct *vmai,enum pci_mmap_api mmap_api);
    struct pci_filp_private {
        enum pci_mmap_state mmap_state;
        int write_combine;
    };

    static int proc_bus_pci_mmap(struct file *file,struct vm_area_struct *vma)
    {
        struct pci_dev *dev = PDE_DATA(file_inode(file));
        struct pci_filp_private *fpriv = file->private_data;
        int i,ret;

        if (!capable(CAP_SYS_RAWIO))
        return -EPERM;

        /* Make sure the caller is mapping a real resource for this device */
        for (i = 0; i < PCI_ROM_RESOURCE; i++) {
        if (pci_mmap_fits(dev,i,vma,PCI_MMAP_PROCFS))
            break;
        }

        if (i >= PCI_ROM_RESOURCE)
        return -ENODEV;
        int bars = pci_select_bars(dev,IORESOURCE_MEM);
      /*  ret = pci_mmap_page_range(dev,bars,fpriv->mmap_state,fpriv->write_combine);
      */  if (ret < 0)
        return ret;

        return 0;
    }
    struct inode *ramfs_get_inode(struct super_block *sb,const struct inode *dir,umode_t mode,dev_t dev)
    {
        struct inode * inode = new_inode(sb);

        if (inode) {
        inode->i_ino = get_next_ino();
        inode_init_owner(inode,dir,mode);
        inode->i_mapping->a_ops = &ramfs_aops;

        mapping_set_gfp_mask(inode->i_mapping,GFP_HIGHUSER);
        mapping_set_unevictable(inode->i_mapping);
        /*inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;*/
        switch (mode & S_IFMT) {
            default:
            init_special_inode(inode,mode,dev);
            break;
            case S_IFREG:
            inode->i_op = &ramfs_file_inode_operations;
            inode->i_fop = &ramfs_file_operations;
            break;
            case S_IFDIR:
            inode->i_op = &ramfs_dir_inode_operations;
            inode->i_fop = &simple_dir_operations;

            /* directory inodes start off with i_nlink == 2 (for "." entry) */
            inc_nlink(inode);
            break;
            case S_IFLNK:
            inode->i_op = &page_symlink_inode_operations;
            break;
        }
        }
        return inode;
    }

    /*
     * File creation. Allocate an inode,and we're done..
     */
    /* SMP-safe */
    static int
    ramfs_mknod(struct inode *dir,struct dentry *dentry,dev_t dev)
    {
        struct inode * inode = ramfs_get_inode(dir->i_sb,dev);
        int error = -ENOSPC;

        if (inode) {
        d_instantiate(dentry,inode);
        dget(dentry);   /* Extra count - pin the dentry in core */
        error = 0;
        /*dir->i_mtime = dir->i_ctime = CURRENT_TIME;*/
        }
        return error;
    }

    static int ramfs_mkdir(struct inode * dir,struct dentry * dentry,umode_t mode)
    {
        int retval = ramfs_mknod(dir,dentry,mode | S_IFDIR,0);
        if (!retval)
        inc_nlink(dir);
        return retval;
    }

    static int ramfs_create(struct inode *dir,bool excl)
    {
        return ramfs_mknod(dir,mode | S_IFREG,0);
    }

    static int ramfs_symlink(struct inode * dir,const char * symname)
    {
        struct inode *inode;
        int error = -ENOSPC;

        inode = ramfs_get_inode(dir->i_sb,S_IFLNK|S_IRWXUGO,0);
        if (inode) {
        int l = strlen(symname)+1;
        error = page_symlink(inode,symname,l);
        if (!error) {
            d_instantiate(dentry,inode);
            dget(dentry);
            /*dir->i_mtime = dir->i_ctime = CURRENT_TIME;*/
        } else
            iput(inode);
        }
        return error;
    }

    static const struct inode_operations ramfs_dir_inode_operations = {
        .create     = ramfs_create,.lookup     = simple_lookup,.link       = simple_link,.unlink     = simple_unlink,.symlink    = ramfs_symlink,.mkdir      = ramfs_mkdir,.rmdir      = simple_rmdir,.mknod      = ramfs_mknod,.rename     = simple_rename,};

    static const struct super_operations ramfs_ops = {
        .statfs     = simple_statfs,.drop_inode = generic_delete_inode,};

    struct ramfs_mount_opts {
        umode_t mode;
    };

    enum {
        Opt_mode,Opt_err
    };

    static const match_table_t tokens = {
        {Opt_mode,"mode=%o"},{Opt_err,NULL}
    };

    struct ramfs_fs_info {
        struct ramfs_mount_opts mount_opts;
    };

    static int ramfs_parse_options(char *data,struct ramfs_mount_opts *opts)
    {
        substring_t args[MAX_OPT_ARGS];
        int option;
        int token;
        char *p;

        opts->mode = RAMFS_DEFAULT_MODE;

        while ((p = strsep(&data,",")) != NULL) {
        if (!*p)
            continue;

        token = match_token(p,tokens,args);
        switch (token) {
            case Opt_mode:
            if (match_octal(&args[0],&option))
                return -EINVAL;
            opts->mode = option & S_IALLUGO;
            break;
            /*
             * We might like to report bad mount options here;
             * but traditionally ramfs has ignored all mount options,* and as it is used as a !CONFIG_SHMEM simple substitute
             * for tmpfs,better continue to ignore other mount options.
             */
        }
        }

        return 0;
    }

    int ramfs_fill_super(struct super_block *sb,void *data,int silent)
    {
        struct ramfs_fs_info *fsi;
        struct inode *inode;
        int err;



        fsi = kzalloc(sizeof(struct ramfs_fs_info),GFP_KERNEL);
        sb->s_fs_info = fsi;
        if (!fsi)
        return -ENOMEM;

        err = ramfs_parse_options(data,&fsi->mount_opts);
        if (err)
        return err;

        sb->s_maxbytes      = MAX_LFS_FILESIZE;
        sb->s_blocksize     = PAGE_SIZE;
        /*sb->s_blocksize_bits    = PAGE_CACHE_SHIFT;*/
        sb->s_magic     = RAMFS_MAGIC;
        sb->s_op        = &ramfs_ops;
        sb->s_time_gran     = 1;

        inode = ramfs_get_inode(sb,NULL,S_IFDIR | fsi->mount_opts.mode,0);
        sb->s_root = d_make_root(inode);
        if (!sb->s_root)
        return -ENOMEM;

        return 0;
    }

    struct dentry *ramfs_mount(struct file_system_type *fs_type,int flags,const char *dev_name,void *data)
    {
        return mount_nodev(fs_type,flags,data,ramfs_fill_super);
    }
    #define MS_NOUSER   (1<<31)
    static struct dentry *rootfs_mount(struct file_system_type *fs_type,flags|MS_NOUSER,ramfs_fill_super);
    }

    static void ramfs_kill_sb(struct super_block *sb)
    {
        kfree(sb->s_fs_info);
        kill_litter_super(sb);
    }

    static struct file_system_type ramfs_fs_type = {
        .name       = "ramfs3",.mount      = ramfs_mount,.kill_sb    = ramfs_kill_sb,.fs_flags   = FS_USERNS_MOUNT,};


    int __init init_ramfs_fs(void)
    {
        return register_filesystem(&ramfs_fs_type);
    }

    module_init(init_ramfs_fs)

    /*
    int __init init_rootfs(void)
    {
        int err;

        err = bdi_init(&ramfs_backing_dev_info);
        if (err)
        return err;

        err = register_filesystem(&rootfs_fs_type);
        if (err)
        bdi_destroy(&ramfs_backing_dev_info);

        return err;
    }




    */

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）