Every ext2 file system has these four sections on disk:

Real ext2 is more complex than the simple layout above. After the boot block, the filesystem is split into equal-sized block groups. Each group has its own copy of the superblock plus its own i-node table and data blocks.

Why block groups? By storing a file’s data blocks and its i-node in the same block group, ext2 reduces disk head movement (seek time) when reading a file.

The file system works in logical blocks, not physical 512-byte sectors. A logical block is a multiple of the physical sector size. You choose the block size when creating the filesystem:

# Create ext4 with 4096-byte blocks (default):
mkfs.ext4 /dev/sdb1

# Create with 1024-byte blocks (for many small files):
mkfs.ext4 -b 1024 /dev/sdb1

# View filesystem details including block size:
dumpe2fs /dev/sdb1 | grep -E "Block size|Block count|Inode count"
# Output:
# Block size:               4096
# Block count:              2621440
# Inode count:              655360

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

int main(int argc, char *argv[]) {
    struct statfs sf;
    const char *path = (argc > 1) ? argv[1] : "/";

    if (statfs(path, &sf) == -1) {
        perror("statfs");
        return 1;
    }

    printf("File system info for: %s\n\n", path);
    printf("Block size:          %ld bytes\n", sf.f_bsize);
    printf("Total blocks:        %lu\n",
           (unsigned long)sf.f_blocks);
    printf("Free blocks:         %lu\n",
           (unsigned long)sf.f_bfree);
    printf("Available blocks:    %lu\n",
           (unsigned long)sf.f_bavail);
    printf("Total i-nodes:       %lu\n",
           (unsigned long)sf.f_files);
    printf("Free i-nodes:        %lu\n",
           (unsigned long)sf.f_ffree);

    /* Calculate total filesystem size */
    double total_gb = (double)sf.f_blocks * sf.f_bsize
                      / (1024.0*1024.0*1024.0);
    double free_gb  = (double)sf.f_bfree  * sf.f_bsize
                      / (1024.0*1024.0*1024.0);

    printf("\nTotal size:          %.2f GB\n", total_gb);
    printf("Free space:          %.2f GB\n",  free_gb);
    printf("Used:                %.1f%%\n",
           100.0 * (sf.f_blocks - sf.f_bfree) / sf.f_blocks);

    /* Filesystem type magic numbers */
    printf("\nFS type magic:       0x%lx", sf.f_type);
    if (sf.f_type == 0xef53)       printf(" (ext2/3/4)");
    else if (sf.f_type == 0x4d44)  printf(" (FAT)");
    else if (sf.f_type == 0x6969)  printf(" (NFS)");
    else if (sf.f_type == 0x52654973) printf(" (ReiserFS)");
    printf("\n");

    return 0;
}

/* Sample output for /:
Block size:          4096 bytes
Total blocks:        10321920
Free blocks:         2456891
Total i-nodes:       2621440
Free i-nodes:        2345123
Total size:          39.37 GB
Free space:          9.37 GB
Used:                76.2%
FS type magic:       0xef53 (ext2/3/4)
*/

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

/* The kernel lists supported filesystems in /proc/filesystems
   "nodev" means it doesn't need a block device (virtual FS) */

int main(void) {
    FILE *fp;
    char line[128];
    int virtual_count = 0, real_count = 0;

    fp = fopen("/proc/filesystems", "r");
    if (!fp) { perror("fopen"); return 1; }

    printf("Virtual FS (nodev):\n");
    while (fgets(line, sizeof(line), fp)) {
        /* Lines with "nodev" = virtual filesystems */
        if (strncmp(line, "nodev", 5) == 0) {
            printf("  %s", line + 6);  /* Skip "nodev\t" */
            virtual_count++;
        }
    }

    rewind(fp);
    printf("\nReal FS (requires block device):\n");
    while (fgets(line, sizeof(line), fp)) {
        if (strncmp(line, "nodev", 5) != 0 && line[0] == '\t') {
            printf("  %s", line + 1);  /* Skip leading tab */
            real_count++;
        }
    }

    printf("\nTotal: %d virtual, %d real filesystems\n",
           virtual_count, real_count);

    fclose(fp);
    return 0;
}

/* Typical output includes:
Virtual FS (nodev):
  sysfs, tmpfs, bdev, proc, cgroup, devtmpfs, etc.
Real FS:
  ext3, ext4, vfat, btrfs, xfs, etc.
*/

#!/bin/bash
# Demonstrate full filesystem lifecycle

# Step 1: Create a disk image file (acts like a partition)
dd if=/dev/zero of=/tmp/myfs.img bs=1M count=100
# Creates a 100MB blank file

# Step 2: Format it as ext4
mkfs.ext4 /tmp/myfs.img
# This writes: boot block, superblock, inode table, data blocks

# Step 3: Mount it
mkdir -p /mnt/mytest
mount -o loop /tmp/myfs.img /mnt/mytest
# loop device maps the file as a block device

# Step 4: Use it like a real filesystem
echo "Hello from ext4!" > /mnt/mytest/hello.txt
mkdir /mnt/mytest/mydir

# Step 5: Check superblock info
dumpe2fs /tmp/myfs.img 2>/dev/null | head -30

# Step 6: Unmount
umount /mnt/mytest

# Step 7: Check filesystem integrity
e2fsck -f /tmp/myfs.img

A privileged program can use FIBMAP ioctl to find where on disk a specific logical block of a file is stored.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fs.h>

/* FIBMAP: given logical block number in file,
   returns starting physical block number on disk.
   Requires CAP_SYS_RAWIO (root) */

int main(int argc, char *argv[]) {
    int fd;
    int logical_block;
    int physical_block;

    if (argc < 3) {
        fprintf(stderr, "Usage: %s <file> <logical_block_num>\n",
                argv[0]);
        return 1;
    }

    fd = open(argv[1], O_RDONLY);
    if (fd == -1) { perror("open"); return 1; }

    logical_block = atoi(argv[2]);
    physical_block = logical_block;  /* Input: logical block # */

    /* FIBMAP replaces physical_block with the actual
       physical disk block number */
    if (ioctl(fd, FIBMAP, &physical_block) == -1) {
        perror("ioctl FIBMAP (need root)");
        close(fd);
        return 1;
    }

    if (physical_block == 0)
        printf("Logical block %d is in a FILE HOLE (no disk storage)\n",
               logical_block);
    else
        printf("Logical block %d -> Physical block %d on disk\n",
               logical_block, physical_block);

    close(fd);
    return 0;
}

/* Run as root:
   ./fibmap /etc/passwd 0
   Output: Logical block 0 -> Physical block 1234567 on disk
*/