如何解决挂载 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 举报，一经查实，本站将立刻删除。
