File Systems Deep Dive — ext4, NTFS, APFS, Btrfs, ZFS & VFS

import struct
import time

class Ext4Inode:
    def __init__(self, inode_num, mode, size, blocks):
        self.inode_num = inode_num
        self.mode = mode  # file type + permissions
        self.size = size
        self.blocks = blocks
        self.atime = time.time()
        self.mtime = time.time()
        self.ctime = time.time()
        self.links_count = 1

    def __repr__(self):
        return (f'Inode {self.inode_num}: '
                f'mode={oct(self.mode)} size={self.size}B '
                f'blocks={self.blocks}')

class Ext4Directory:
    def __init__(self):
        self.entries = {}  # name -> inode_num

    def create_file(self, name, inode_num, size=0):
        self.entries[name] = inode_num
        return Ext4Inode(inode_num, 0o100644, size, (size + 4095) // 4096)

    def ls(self):
        for name, inode in sorted(self.entries.items(),
                                  key=lambda x: x[0]):
            print(f'{name:20s} → inode {inode}')

# Simulate creating files
root = Ext4Directory()
inodes = {}
inodes[1] = root.create_file('readme.txt', 1, 2048)
inodes[2] = root.create_file('script.sh', 2, 512)
inodes[3] = root.create_file('data.csv', 3, 16384)
inodes[4] = Ext4Inode(4, 0o100755, 12345, 4)

root.ls()
print(f'\n{inodes[3]}')
print(f'Blocks on disk: {inodes[3].blocks}')

class NTFSMFTEntry:
    def __init__(self, record_num, filename, is_directory=False):
        self.record_num = record_num
        self.filename = filename
        self.is_directory = is_directory
        self.attributes = {}
        self.resident_data = b''

    def add_attribute(self, attr_type, data, resident=True):
        self.attributes[attr_type] = {
            'type': attr_type,
            'resident': resident,
            'size': len(data) if isinstance(data, bytes) else data
        }
        if resident and isinstance(data, bytes):
            self.resident_data = data

    def __repr__(self):
        attrs = ', '.join(self.attributes.keys())
        return (f'MFT Entry {self.record_num}: '
                f'{self.filename} [{attrs}]')

# Simulate MFT entries
mft = {}
mft[0] = NTFSMFTEntry(0, '$MFT')
mft[0].add_attribute('STANDARD_INFORMATION', '...')
mft[0].add_attribute('FILE_NAME', '$MFT')

mft[5] = NTFSMFTEntry(5, 'document.docx')
mft[5].add_attribute('STANDARD_INFORMATION', '...')
mft[5].add_attribute('FILE_NAME', 'document.docx')
mft[5].add_attribute('DATA', 1024 * 1024, resident=False)  # 1MB

mft[6] = NTFSMFTEntry(6, 'notes.txt')
mft[6].add_attribute('STANDARD_INFORMATION', '...')
mft[6].add_attribute('FILE_NAME', 'notes.txt')
mft[6].add_attribute('DATA', b'Hello, NTFS!', resident=True)

for entry in mft.values():
    print(entry)

class APFSBlock:
    def __init__(self, block_id, data=b''):
        self.block_id = block_id
        self.data = data
        self.ref_count = 1

class APFSFile:
    def __init__(self, name, data_blocks):
        self.name = name
        self.data_blocks = data_blocks  # list of block IDs

    def modify(self, offset, new_data, block_allocator):
        """Copy-on-write: allocate new block, leave old block intact"""
        old_id = self.data_blocks[offset]
        new_id = block_allocator.allocate(new_data)
        self.data_blocks[offset] = new_id
        block_allocator.decrement_ref(old_id)
        return old_id  # old block is preserved if cloned

class APFSBlockAllocator:
    def __init__(self):
        self.blocks = {}
        self.next_id = 0

    def allocate(self, data):
        block = APFSBlock(self.next_id, data)
        self.blocks[self.next_id] = block
        self.next_id += 1
        return block.block_id

    def decrement_ref(self, block_id):
        self.blocks[block_id].ref_count -= 1
        if self.blocks[block_id].ref_count == 0:
            print(f'  Freed block {block_id} (no more references)')

# Simulate CoW
allocator = APFSBlockAllocator()
file = APFSFile('document.txt', [
    allocator.allocate(b'Hello World!'),
    allocator.allocate(b'Second block'),
])

print(f'Before modification: blocks {file.data_blocks}')
old_block = file.modify(0, b'Modified data', allocator)
print(f'After CoW modification: blocks {file.data_blocks}')
print(f'Old block {old_block} preserved (might be referenced by snapshot)')

class VFSNode:
    def __init__(self, name, is_directory=False):
        self.name = name
        self.is_directory = is_directory
        self.children = {}
        self.data = b''

    def open(self, path):
        parts = path.strip('/').split('/')
        node = self
        for part in parts:
            if part in node.children:
                node = node.children[part]
            else:
                raise FileNotFoundError(path)
        return node

    def read(self):
        if self.is_directory:
            return list(self.children.keys())
        return self.data

    def write(self, data):
        self.data = data
        return len(data)

# Simulate VFS
root = VFSNode('/', is_directory=True)
home = VFSNode('home', is_directory=True)
root.children['home'] = home
readme = VFSNode('readme.txt')
readme.write(b'Hello from VFS!')
home.children['readme.txt'] = readme

node = root.open('/home/readme.txt')
print(f'Opened: /home/{node.name}')
print(f'Content: {node.read()}')

node2 = root.open('/home')
print(f'Directory listing: {node2.read()}')

import os

class SimulatedFS:
    def __init__(self):
        self.inodes = {}
        self.dir_entries = {}

    def create_file(self, path, data):
        inode_num = len(self.inodes) + 1
        self.inodes[inode_num] = {'data': data, 'links': 1}
        self.dir_entries[path] = inode_num
        return inode_num

    def hard_link(self, src, dst):
        if src in self.dir_entries:
            inode = self.dir_entries[src]
            self.dir_entries[dst] = inode
            self.inodes[inode]['links'] += 1
            print(f'Hard link: {dst} → {src} (same inode {inode})')

    def sym_link(self, src, dst):
        # Symbolic link stores the path string
        self.dir_entries[dst] = f'SYMLINK→{src}'
        print(f'Sym link: {dst} → {src} (path: {src})')

    def delete(self, path):
        entry = self.dir_entries.get(path)
        if isinstance(entry, int):
            self.inodes[entry]['links'] -= 1
            if self.inodes[entry]['links'] == 0:
                del self.inodes[entry]
                print(f'Inode {entry} freed')
        del self.dir_entries[path]

fs = SimulatedFS()
fs.create_file('/original.txt', b'Hello!')
fs.hard_link('/original.txt', '/hardlink.txt')
fs.sym_link('/original.txt', '/symlink.txt')

print(f'\nDelete /original.txt')
fs.delete('/original.txt')
print(f'Hard link still works: inode {fs.dir_entries["/hardlink.txt"]}')
print(f'Sym link: {fs.dir_entries["/symlink.txt"]} (broken!)')