File Systems — NTFS, ext4, APFS & ZFS Comparison Guide

class Ext4Inode:
    def __init__(self, inode_num, mode, size, blocks):
        self.inode_num = inode_num
        self.mode = mode
        self.size = size
        self.blocks = blocks
        self.links_count = 1

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

class Ext4Directory:
    def __init__(self):
        self.entries = {}

    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}')

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)
root.ls()
print(f'\n{inodes[3]}')

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 = {}

    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}

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

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('DATA', 1024 * 1024, resident=False)
mft[6] = NTFSMFTEntry(6, '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

    def modify(self, offset, new_data, block_allocator):
        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

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}')

allocator = APFSBlockAllocator()
file = APFSFile('document.txt', [
    allocator.allocate(b'Hello World!'),
    allocator.allocate(b'Second block'),
])
print(f'Before: blocks {file.data_blocks}')
old_block = file.modify(0, b'Modified data', allocator)
print(f'After: blocks {file.data_blocks}')
print(f'Old block {old_block} preserved (snapshot reference)')

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

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()}')

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):
        inode = self.dir_entries[src]
        self.dir_entries[dst] = inode
        self.inodes[inode]['links'] += 1
        print(f'Hard link: {dst} → {src} (inode {inode})')

    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')
print(f'Delete /original.txt')
fs.delete('/original.txt')
print(f'Hard link still works: inode {fs.dir_entries["/hardlink.txt"]}')

class SimpleFS:
    def __init__(self, block_size=512):
        self.block_size = block_size
        self.blocks = {}
        self.files = {}
        self.next_block = 0

    def alloc_block(self, data=b''):
        bid = self.next_block
        self.blocks[bid] = bytearray(data or b'\x00' * self.block_size)
        self.next_block += 1
        return bid

    def write_file(self, name, data):
        blocks = []
        for i in range(0, len(data), self.block_size):
            blocks.append(self.alloc_block(data[i:i+self.block_size]))
        self.files[name] = blocks
        return len(data)

    def read_file(self, name):
        data = bytearray()
        for bid in self.files.get(name, []):
            data.extend(self.blocks[bid][:self.block_size])
        return bytes(data).rstrip(b'\x00')

fs = SimpleFS()
fs.write_file("hello.txt", b"Hello File System!")
print(fs.read_file("hello.txt").decode())