VFS defines a standard set of function pointers (operations) that every filesystem must implement. The kernel calls these generic functions; each filesystem provides its own version.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>

/* This exact same code works on ext4, XFS, FAT32, NFS, tmpfs —
   VFS routes each call to the right driver automatically */

int copy_file(const char *src, const char *dst) {
    int fd_in, fd_out;
    char buf[4096];
    ssize_t nread;

    /* open() — VFS calls the right fs driver's open() */
    fd_in = open(src, O_RDONLY);
    if (fd_in == -1) { perror("open src"); return -1; }

    fd_out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd_out == -1) {
        perror("open dst");
        close(fd_in);
        return -1;
    }

    /* read()/write() — VFS handles the routing */
    while ((nread = read(fd_in, buf, sizeof(buf))) > 0)
        write(fd_out, buf, nread);

    close(fd_in);
    close(fd_out);
    return 0;
}

int main(void) {
    /* Copy from ext4 to tmpfs — VFS handles both transparently */
    copy_file("/etc/hostname", "/tmp/hostname_copy");

    /* Check what filesystem /tmp is on */
    struct statfs sf;
    statfs("/tmp", &sf);
    if (sf.f_type == 0x01021994)  /* tmpfs magic */
        printf("/tmp is on tmpfs (RAM-based)\n");

    printf("File copied successfully via VFS\n");
    return 0;
}

/* The key point: you never write filesystem-specific code.
   VFS gives you one API for everything. */

FUSE (Filesystem in Userspace, added in Linux 2.6.14) lets you write a complete filesystem in a regular program — no kernel module needed.

/* Minimal FUSE "hello world" filesystem.
   Install libfuse-dev, compile with: gcc -o hello hello_fs.c -lfuse3
   Mount with: ./hello /mnt/myfs
*/

#define FUSE_USE_VERSION 31
#include <fuse3/fuse.h>
#include <string.h>
#include <errno.h>

/* Our filesystem has one file: /hello.txt */

/* Called when ls runs — return file/dir names */
static int my_readdir(const char *path, void *buf,
                      fuse_fill_dir_t filler, off_t offset,
                      struct fuse_file_info *fi,
                      enum fuse_readdir_flags flags) {
    if (strcmp(path, "/") != 0)
        return -ENOENT;

    filler(buf, ".",        NULL, 0, 0);  /* current dir */
    filler(buf, "..",       NULL, 0, 0);  /* parent dir */
    filler(buf, "hello.txt", NULL, 0, 0); /* our file */
    return 0;
}

/* Called when stat() / ls -l runs on a file */
static int my_getattr(const char *path, struct stat *st,
                      struct fuse_file_info *fi) {
    memset(st, 0, sizeof(*st));
    if (strcmp(path, "/") == 0) {
        st->st_mode = S_IFDIR | 0755;
        st->st_nlink = 2;
    } else if (strcmp(path, "/hello.txt") == 0) {
        st->st_mode = S_IFREG | 0444;
        st->st_nlink = 1;
        st->st_size = 13;  /* "Hello, FUSE!\n" */
    } else {
        return -ENOENT;
    }
    return 0;
}

/* Called when a program reads the file */
static int my_read(const char *path, char *buf, size_t size,
                   off_t offset, struct fuse_file_info *fi) {
    const char *content = "Hello, FUSE!\n";
    size_t len = strlen(content);

    if (strcmp(path, "/hello.txt") != 0) return -ENOENT;
    if (offset >= (off_t)len) return 0;

    if (offset + size > len) size = len - offset;
    memcpy(buf, content + offset, size);
    return size;
}

/* Register our functions with FUSE */
static const struct fuse_operations ops = {
    .getattr = my_getattr,
    .readdir = my_readdir,
    .read    = my_read,
};

int main(int argc, char *argv[]) {
    return fuse_main(argc, argv, &ops, NULL);
}

/* After mounting:
   cat /mnt/myfs/hello.txt  -> "Hello, FUSE!"
   ls /mnt/myfs             -> hello.txt
   All routing done by VFS/FUSE kernel hooks!
*/

#include <stdio.h>
#include <sys/vfs.h>

/* Filesystem magic numbers */
#define EXT2_MAGIC    0xef53
#define EXT4_MAGIC    0xef53  /* same magic! ext3/ext4 extend ext2 */
#define XFS_MAGIC     0x58465342
#define BTRFS_MAGIC   0x9123683e
#define TMPFS_MAGIC   0x01021994
#define NFS_MAGIC     0x6969
#define FAT_MAGIC     0x4d44
#define REISERFS_MAGIC 0x52654973

const char *fs_name(long magic) {
    switch (magic) {
        case EXT2_MAGIC:     return "ext2/ext3/ext4";
        case XFS_MAGIC:      return "XFS";
        case BTRFS_MAGIC:    return "Btrfs";
        case TMPFS_MAGIC:    return "tmpfs";
        case NFS_MAGIC:      return "NFS";
        case FAT_MAGIC:      return "FAT";
        case REISERFS_MAGIC: return "ReiserFS";
        default:             return "unknown";
    }
}

int main(int argc, char *argv[]) {
    struct statfs sf;
    const char *paths[] = {"/", "/tmp", "/proc", "/sys", NULL};
    const char **p;

    for (p = paths; *p; p++) {
        if (statfs(*p, &sf) == 0)
            printf("%-10s -> %s (magic=0x%lx)\n",
                   *p, fs_name(sf.f_type), sf.f_type);
    }
    return 0;
}

/* Typical output:
/          -> ext2/ext3/ext4 (magic=0xef53)
/tmp       -> tmpfs           (magic=0x1021994)
/proc      -> proc            (magic=0x9fa0)
/sys       -> sysfs           (magic=0x62656572)
*/

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

/* Simplified demo of write-ahead logging concept.
   Real journaling is in the kernel, but this shows the IDEA. */

typedef struct {
    int  transaction_id;
    char operation[32];  /* e.g., "write_inode" */
    char data[64];       /* simplified data */
    int  committed;      /* 0=pending, 1=committed */
} JournalEntry;

int write_to_journal(const char *journal_path,
                     JournalEntry *entry) {
    int fd = open(journal_path, O_WRONLY | O_APPEND | O_CREAT, 0644);
    if (fd == -1) return -1;

    /* Step 1: Write the entry to journal */
    write(fd, entry, sizeof(*entry));

    /* Step 2: Flush to disk BEFORE applying to real FS */
    fsync(fd);  /* Force kernel to flush to disk NOW */

    close(fd);
    printf("[JOURNAL] Wrote tx#%d: %s\n",
           entry->transaction_id, entry->operation);
    return 0;
}

void commit_transaction(JournalEntry *entry) {
    entry->committed = 1;
    printf("[JOURNAL] Committed tx#%d\n", entry->transaction_id);
    /* Now safe to apply to actual filesystem */
}

int main(void) {
    JournalEntry tx1, tx2;

    /* Simulate writing a file (3 metadata updates) */
    tx1.transaction_id = 1;
    strncpy(tx1.operation, "update_inode_size", 31);
    strncpy(tx1.data,      "size=1024",         63);
    tx1.committed = 0;
    write_to_journal("/tmp/demo_journal.log", &tx1);

    tx2.transaction_id = 2;
    strncpy(tx2.operation, "update_dir_entry", 31);
    strncpy(tx2.data,      "name=newfile.txt", 63);
    tx2.committed = 0;
    write_to_journal("/tmp/demo_journal.log", &tx2);

    /* Commit both as a group (atomically) */
    commit_transaction(&tx1);
    commit_transaction(&tx2);

    printf("\nIf crash occurs BEFORE commit: journal ignored (FS safe)\n");
    printf("If crash occurs AFTER commit:  journal replayed (FS recovered)\n");

    return 0;
}

/* Key: fsync() is critical — it forces the journal write to
   physical disk, not just kernel buffer cache.
   Without fsync, the journal itself might be lost on crash. */