Virtual File System (VFS)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

struct file_system_type {
    /* Identification */
    const char          *name;          /* File system name (e.g., "ext4") */
    
    /* Flags describing capabilities */
    int                 fs_flags;       /* Flags (see below) */
    
    /* Mount function - THE critical method */
    int (*init_fs_context)(struct fs_context *);
    /* OR older interface: */
    struct dentry *(*mount)(struct file_system_type *, int,
                            const char *, void *);
    
    /* Context parameters */
    const struct fs_parameter_spec *parameters;
    
    /* Unmount cleanup */
    void (*kill_sb)(struct super_block *);
    
    /* Module owner */
    struct module       *owner;         /* Module providing this FS */
    
    /* Linked list of registered file systems */
    struct file_system_type *next;
    
    /* List of all superblocks for this file system type */
    struct hlist_head   fs_supers;
    
    /* Locking */
    struct lock_class_key s_lock_key;
    struct lock_class_key s_umount_key;
    struct lock_class_key s_vfs_rename_key;
    struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
    struct lock_class_key i_lock_key;
    struct lock_class_key i_mutex_key;
    struct lock_class_key invalidate_lock_key;
    struct lock_class_key i_mutex_dir_key;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/* File system requires a real block device */
#define FS_REQUIRES_DEV         1
 
/* Filesystem will handle binary mount data (not text options) */
#define FS_BINARY_MOUNTDATA     2
 
/* Has subtype (like FUSE: fuse.sshfs) */
#define FS_HAS_SUBTYPE          4
 
/* Can be mounted by user namespace root */
#define FS_USERNS_MOUNT         8
 
/* Disable fanotify permission events */
#define FS_DISALLOW_NOTIFY_PERM 16
 
/* File system is safe for RENAME_EXCHANGE */
#define FS_RENAME_DOES_D_MOVE   32768

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/* Global list of registered file systems */
static struct file_system_type *file_systems;
static DEFINE_RWLOCK(file_systems_lock);
 
/**
 * register_filesystem - register a new file system
 * @fs: the file system structure to register
 *
 * Adds the file system to the list of known file systems.
 * Returns 0 on success, negative error on failure.
 */
int register_filesystem(struct file_system_type *fs)
{
    int res = 0;
    struct file_system_type **p;
 
    /* Sanity check: must have a name */
    if (fs->next)
        return -EBUSY;
 
    write_lock(&file_systems_lock);
    
    /* Walk the list to check for duplicates and find end */
    p = &file_systems;
    while (*p) {
        if (strcmp((*p)->name, fs->name) == 0) {
            /* Already registered with this name! */
            res = -EBUSY;
            goto out;
        }
        p = &(*p)->next;
    }
    
    /* Add to end of list */
    *p = fs;
    
out:
    write_unlock(&file_systems_lock);
    return res;
}
EXPORT_SYMBOL(register_filesystem);
 
/**
 * unregister_filesystem - unregister a file system
 * @fs: file system type to remove
 */
int unregister_filesystem(struct file_system_type *fs)
{
    struct file_system_type **p;
    int err = -EINVAL;
 
    write_lock(&file_systems_lock);
    
    /* Find and remove from list */
    for (p = &file_systems; *p; p = &(*p)->next) {
        if (*p == fs) {
            *p = fs->next;
            fs->next = NULL;
            err = 0;
            break;
        }
    }
    
    write_unlock(&file_systems_lock);
    return err;
}
EXPORT_SYMBOL(unregister_filesystem);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/**
 * get_fs_type - find a file system type by name
 * @name: name of the file system (e.g., "ext4")
 *
 * Returns the file system type structure, or NULL if not found.
 * May trigger module autoload for "fs-<name>" or "fs-<base>".
 */
struct file_system_type *get_fs_type(const char *name)
{
    struct file_system_type *fs;
    const char *dot = strchr(name, '.');
    int len = dot ? dot - name : strlen(name);
 
    /* First, try to find it in the registered list */
    fs = __get_fs_type(name, len);
    
    /* If not found, try to load a module */
    if (!fs && (request_module("fs-%.*s", len, name) == 0)) {
        /* Module loaded, try again */
        fs = __get_fs_type(name, len);
    }
 
    if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
        put_filesystem(fs);
        fs = NULL;
    }
    return fs;
}
 
/* Actually search the registered list */
static struct file_system_type *__get_fs_type(const char *name, int len)
{
    struct file_system_type *fs;
 
    read_lock(&file_systems_lock);
    for (fs = file_systems; fs; fs = fs->next) {
        if (strncmp(fs->name, name, len) == 0 && 
            !fs->name[len]) {
            if (!try_module_get(fs->owner))
                fs = NULL;
            break;
        }
    }
    read_unlock(&file_systems_lock);
    return fs;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

/* For file systems requiring a block device (ext4, xfs, etc.) */
static struct dentry *ext4_mount(struct file_system_type *fs_type,
                                  int flags, const char *dev_name,
                                  void *data)
{
    return mount_bdev(fs_type, flags, dev_name, data, ext4_fill_super);
}
 
/* mount_bdev: Opens the block device, calls fill_super */
struct dentry *mount_bdev(struct file_system_type *fs_type, int flags,
                          const char *dev_name, void *data,
                          int (*fill_super)(struct super_block *, 
                                            void *, int))
{
    struct block_device *bdev;
    struct super_block *s;
    
    /* Open the block device */
    bdev = blkdev_get_by_path(dev_name, mode, fs_type);
    if (IS_ERR(bdev))
        return ERR_CAST(bdev);
    
    /* Get or create a superblock for this device */
    s = sget(fs_type, test_bdev_super, set_bdev_super, flags, bdev);
    
    if (s->s_root) {
        /* Already mounted - return existing root */
        return dget(s->s_root);
    }
    
    /* New mount - set up the superblock */
    s->s_bdev = bdev;
    s->s_dev = bdev->bd_dev;
    
    /* Call file system's fill_super to initialize */
    error = fill_super(s, data, flags & SB_SILENT ? 1 : 0);
    if (error)
        goto error_out;
    
    return dget(s->s_root);
}
 
/* For pseudo-filesystems (proc, sysfs, tmpfs) */
static struct dentry *proc_mount(struct file_system_type *fs_type,
                                  int flags, const char *dev_name,
                                  void *data)
{
    return mount_ns(fs_type, flags, data, pid_ns, proc_fill_super);
}
 
/* For single-instance filesystems */
static struct dentry *sysfs_mount(struct file_system_type *fs_type,
                                   int flags, const char *dev_name,
                                   void *data)
{
    return mount_single(fs_type, flags, data, sysfs_fill_super);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

/* Forward declaration of fs_context */
struct fs_context {
    const struct fs_context_operations *ops;
    struct file_system_type *fs_type;
    void                *fs_private;      /* FS-specific data */
    struct super_block  *root;            /* Resulting superblock */
    struct user_namespace *user_ns;       /* User namespace */
    struct net          *net_ns;          /* Network namespace */
    const struct cred   *cred;            /* Credentials to use */
    char                *source;          /* Source (device name) */
    void                *security;        /* LSM context */
    unsigned int        sb_flags;         /* Proposed superblock flags */
    unsigned int        sb_flags_mask;    /* Flags being modified */
    unsigned int        purpose:8;        /* Mount purpose */
    /* ... more fields ... */
};
 
/* Operations the file system provides */
struct fs_context_operations {
    /* Free the fs_context */
    void (*free)(struct fs_context *fc);
    
    /* Duplicate for fork of mount process */
    int (*dup)(struct fs_context *fc, struct fs_context *src);
    
    /* Parse a single mount option */
    int (*parse_param)(struct fs_context *fc, struct fs_parameter *param);
    
    /* Parse a monolithic mount data string (legacy compatibility) */
    int (*parse_monolithic)(struct fs_context *fc, void *data);
    
    /* Actually perform the mount */
    int (*get_tree)(struct fs_context *fc);
    
    /* Reconfigure (remount) an existing superblock */
    int (*reconfigure)(struct fs_context *fc);
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/* Define the mount parameters ext4 accepts */
static const struct fs_parameter_spec ext4_param_specs[] = {
    fsparam_flag("bsddf",           Opt_bsd_df),
    fsparam_flag("minixdf",         Opt_minix_df),
    fsparam_flag("nogrpid",         Opt_no_grpid),
    fsparam_u32("resgid",           Opt_resgid),
    fsparam_u32("resuid",           Opt_resuid),
    fsparam_u32("sb",               Opt_sb),
    fsparam_enum("errors",          Opt_errors, ext4_param_errors),
    fsparam_string("data",          Opt_data),
    fsparam_flag_no("acl",          Opt_acl),
    fsparam_flag_no("user_xattr",   Opt_user_xattr),
    fsparam_u32("commit",           Opt_commit),
    fsparam_u32("max_batch_time",   Opt_max_batch_time),
    {}  /* Terminator */
};
 
/* Parse individual parameters */
static int ext4_parse_param(struct fs_context *fc,
                            struct fs_parameter *param)
{
    struct ext4_fs_context *ctx = fc->fs_private;
    struct fs_parse_result result;
    int opt;
 
    /* Use generic parameter parser */
    opt = fs_parse(fc, ext4_param_specs, param, &result);
    if (opt < 0)
        return opt;
 
    switch (opt) {
    case Opt_bsd_df:
        ctx->mount_opt |= EXT4_MOUNT_MINIX_DF;
        break;
    case Opt_resgid:
        ctx->s_resgid = make_kgid(fc->user_ns, result.uint_32);
        break;
    case Opt_commit:
        ctx->s_commit_interval = result.uint_32;
        break;
    /* ... handle each option ... */
    }
    return 0;
}
 
/* Perform the actual mount */
static int ext4_get_tree(struct fs_context *fc)
{
    return get_tree_bdev(fc, ext4_fill_super);
}
 
static const struct fs_context_operations ext4_context_ops = {
    .free           = ext4_fc_free,
    .parse_param    = ext4_parse_param,
    .get_tree       = ext4_get_tree,
    .reconfigure    = ext4_reconfigure,
};
 
/* Create an fs_context for ext4 */
static int ext4_init_fs_context(struct fs_context *fc)
{
    struct ext4_fs_context *ctx;
 
    ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
    if (!ctx)
        return -ENOMEM;
    
    /* Set defaults */
    ctx->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE;
    /* ... more defaults ... */
 
    fc->fs_private = ctx;
    fc->ops = &ext4_context_ops;
    return 0;
}
 
/* Register with the new callback */
static struct file_system_type ext4_fs_type = {
    .name           = "ext4",
    .fs_flags       = FS_REQUIRES_DEV,
    .init_fs_context = ext4_init_fs_context,
    .parameters     = ext4_param_specs,
    .kill_sb        = ext4_kill_sb,
    .owner          = THIS_MODULE,
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

/*
 * simplefs - A minimal example file system
 * Shows the essential VFS registration pattern
 */
 
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
 
#define SIMPLEFS_MAGIC 0x534D504C  /* 'SMPL' */
 
/* Super operations - what the file system provides for superblock */
static const struct super_operations simplefs_super_ops = {
    .statfs     = simple_statfs,    /* Use generic implementation */
    .drop_inode = generic_delete_inode,
};
 
/* Fill superblock during mount */
static int simplefs_fill_super(struct super_block *sb, void *data, int silent)
{
    struct inode *root_inode;
    struct dentry *root_dentry;
 
    /* Configure superblock */
    sb->s_magic = SIMPLEFS_MAGIC;
    sb->s_op = &simplefs_super_ops;
    sb->s_maxbytes = MAX_LFS_FILESIZE;
    sb->s_blocksize = PAGE_SIZE;
    sb->s_blocksize_bits = PAGE_SHIFT;
    sb->s_time_gran = 1;
 
    /* Create root inode */
    root_inode = new_inode(sb);
    if (!root_inode)
        return -ENOMEM;
 
    root_inode->i_ino = 1;
    root_inode->i_sb = sb;
    root_inode->i_mode = S_IFDIR | 0755;
    root_inode->i_uid = KUIDT_INIT(0);
    root_inode->i_gid = KGIDT_INIT(0);
    root_inode->i_atime = root_inode->i_mtime = 
        root_inode->i_ctime = current_time(root_inode);
    root_inode->i_op = &simple_dir_inode_operations;
    root_inode->i_fop = &simple_dir_operations;
 
    /* Create root dentry */
    root_dentry = d_make_root(root_inode);
    if (!root_dentry) {
        iput(root_inode);
        return -ENOMEM;
    }
    sb->s_root = root_dentry;
 
    return 0;
}
 
/* Mount callback - uses nodev helper (no block device needed) */
static struct dentry *simplefs_mount(struct file_system_type *fs_type,
                                     int flags, const char *dev_name,
                                     void *data)
{
    return mount_nodev(fs_type, flags, data, simplefs_fill_super);
}
 
/* Cleanup on unmount */
static void simplefs_kill_sb(struct super_block *sb)
{
    kill_litter_super(sb);  /* Clean up pseudo-FS superblock */
}
 
/* The file system type structure - our registration data */
static struct file_system_type simplefs_type = {
    .name       = "simplefs",
    .fs_flags   = 0,  /* No FS_REQUIRES_DEV - in-memory only */
    .mount      = simplefs_mount,
    .kill_sb    = simplefs_kill_sb,
    .owner      = THIS_MODULE,
};
 
/* Module initialization - called when module loads */
static int __init simplefs_init(void)
{
    int ret;
 
    pr_info("simplefs: Registering file system\n");
    
    ret = register_filesystem(&simplefs_type);
    if (ret) {
        pr_err("simplefs: Registration failed: %d\n", ret);
        return ret;
    }
    
    pr_info("simplefs: Successfully registered\n");
    return 0;
}
 
/* Module cleanup - called when module unloads */
static void __exit simplefs_exit(void)
{
    pr_info("simplefs: Unregistering file system\n");
    unregister_filesystem(&simplefs_type);
}
 
module_init(simplefs_init);
module_exit(simplefs_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Example Author");
MODULE_DESCRIPTION("A minimal example file system");
MODULE_ALIAS_FS("simplefs");