// This file is part of the Essence operating system.
// It is released under the terms of the MIT license -- see LICENSE.md.
// Written by: nakst.

// TODO Kernel driver:
// 		Extent allocation algorithm.
// TODO Design:
// 		Meta/flex block groups.
// 		Journal.
// 		Inline b-tree.
// 		Further data indirection. 
// 		Hash collisions. (Probably just remove index and enumerate directory contents instead?)

#ifndef KERNEL

#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#ifndef _BSD_SOURCE
#define _BSD_SOURCE
#endif

#ifndef OS_ESSENCE
typedef struct EsUniqueIdentifier {
	uint8_t d[16];
} EsUniqueIdentifier;
#endif

#endif

#define ESFS_BOOT_SUPER_BLOCK_SIZE 			(8192)			// The bootloader and superblock take up 16KB.
#define ESFS_DRIVE_MINIMUM_SIZE 			(1048576)		// The minimum drive size that can be formatted.
#define ESFS_DRIVER_VERSION 				(10)			// The current driver version.
#define ESFS_MAXIMUM_VOLUME_NAME_LENGTH 		(32)			// The volume name limit.

#define ESFS_CORE_NODE_KERNEL				(0)			// The kernel core node.
#define ESFS_CORE_NODE_ROOT				(1)			// The root directory core node.
#define ESFS_CORE_NODE_COUNT				(2)			// The number of core nodes.

#define ESFS_SIGNATURE_STRING        			("!EssenceFS2-----")	// The signature in the superblock.
#define ESFS_DIRECTORY_ENTRY_SIGNATURE 			("DirEntry")		// The signature in directory entries.
#define ESFS_GROUP_DESCRIPTOR_SIGNATURE			("GDTE")		// The signature in a group descriptor.
#define ESFS_INDEX_VERTEX_SIGNATURE			("INXE")		// The signature in a index vertex.

#define ESFS_NODE_TYPE_FILE 				(1)			// DirectoryEntry.nodeType: a file.
#define ESFS_NODE_TYPE_DIRECTORY 			(2)			// DirectoryEntry.nodeType: a directory.

#define ESFS_ATTRIBUTE_DATA				(1)			// Contains the data of the file, or a list of DirectoryEntries.
#define ESFS_ATTRIBUTE_FILENAME				(2)			// The UTF-8 filename.
#define ESFS_ATTRIBUTE_DIRECTORY			(3)			// Additional information about the directory.

#define ESFS_INDIRECTION_DIRECT				(1)			// The data is stored in the attribute.
#define ESFS_INDIRECTION_L1				(2)			// The attribute contains a extent list that points to the data.

#define ESFS_INDEX_MAX_DEPTH				(16)			// The maximum depth of the index tree. I'd be surprised if this gets past 8.
#define ESFS_VERTEX_KEY(vertex, key) 			((IndexKey *) ((uint8_t *) vertex + vertex->offset) + key)

typedef struct Attribute {
	/*  0 */ uint16_t type;						// Attribute type.
	/*  2 */ uint16_t size;						// The size in bytes. Must be 8 byte aligned.
} Attribute;

typedef struct AttributeFilename {
	/*  0 */ uint16_t type;						// ESFS_ATTRIBUTE_FILENAME.
	/*  2 */ uint16_t size;						// The size in bytes. Must be 8 byte aligned.
	/*  4 */ uint16_t length;					// The length of the filename in bytes.
	/*  6 */ uint16_t _unused;					// Unused.

#define ESFS_FILENAME_HEADER_SIZE (8)						// The size of the header of a AttributeFilename.
	/*  8 */ uint8_t filename[1];					// The UTF-8 filename.
} AttributeFilename;

typedef struct AttributeDirectory {
	/*  0 */ uint16_t type;						// ESFS_ATTRIBUTE_DIRECTORY.
	/*  2 */ uint16_t size;						// The size in bytes. Must be 8 byte aligned.
	/*  4 */ uint8_t _unused0[4];
	/*  8 */ uint64_t childNodes;					// The number of child nodes in the directory.
	/* 16 */ uint64_t indexRootBlock;				// The block containing the root IndexVertex for the directory.
	/* 24 */ uint64_t totalSize;					// The sum of sizes of all the directory's children in bytes.
} AttributeDirectory;

typedef struct AttributeData {
	/*  0 */ uint16_t type;						// ESFS_ATTRIBUTE_DATA.
	/*  2 */ uint16_t size;						// The size in bytes. Must be 8 byte aligned.
	/*  4 */ uint8_t indirection;					// The indirection used to access the data.
	/*  5 */ uint8_t dataOffset;					// The offset into the attribute where the data or extent list can be found.
	/*  6 */ uint16_t count;					// The number of data bytes in the attribute, or extents in the list.
	/*  8 */ uint64_t _unused[3];					// Unused.
#define ESFS_DATA_OFFSET (32)
	/* 32 */ uint8_t data[1];					// The data or extent list.

	// Format of each extent in the extent list:
	//       uint8_t offsetSize : 3, countSize : 3, unused : 2;	// The size of the offset and count fields in bytes - 1.
	//       uint8_t offset[offsetSize + 1];			// The first block in the extent, expressed as a signed offset from the start 
	//       							       of the previous extent in the list, or from 0 for the first extent. Big endian.
	//       uint8_t count[countSize + 1];				// The number of blocks encompassed by the extent. Big endian.
} AttributeData;

typedef struct DirectoryEntry {
	/*  0 */ char signature[8];					// Must be ESFS_DIRECTORY_ENTRY_SIGNATURE.
	/*  8 */ EsUniqueIdentifier identifier;				// Identifier of the node.
	/* 24 */ uint32_t checksum;					// CRC-32 checksum of DirectoryEntry.
	/* 28 */ uint16_t attributeOffset;				// Offset to the first attribute.
	/* 30 */ uint8_t nodeType;					// Node type.
	/* 31 */ uint8_t attributeCount;				// The number of attributes in the list.
	/* 32 */ uint64_t creationTime, accessTime, modificationTime;	// Timekeeping. In microseconds since 1st January 1970.
	/* 56 */ uint64_t fileSize;					// The amount of data referenced by the data attribute in bytes.
	/* 64 */ EsUniqueIdentifier parent;				// Identifier of the parent directory.
	/* 80 */ EsUniqueIdentifier contentType;                        // Identifier of the file content type.

#define ESFS_ATTRIBUTE_OFFSET (96)
	/* 96 */ uint8_t attributes[1024 - ESFS_ATTRIBUTE_OFFSET];	// Attribute list.
} DirectoryEntry;

typedef struct GroupDescriptor {
	/*  0 */ char signature[4];					// Must be ESFS_GROUP_DESCRIPTOR_SIGNATURE.
	/*  4 */ uint32_t blocksUsed;					// The number of used blocks in the group.
	/*  8 */ uint64_t blockBitmap;					// The bitmap indicating which blocks in the group are used.
	/* 16 */ uint32_t bitmapChecksum;				// CRC-32 checksum of the bitmap.
	/* 20 */ uint32_t checksum;					// CRC-32 checksum of this descriptor.
	/* 24 */ uint32_t largestExtent;				// The largest number of contiguous blocks.
	/* 28 */ uint32_t _unused[7];					// Unused.
} GroupDescriptor;

typedef struct DirectoryEntryReference {
	/*  0 */ uint64_t block;					// The block containing the directory entry.
	/*  8 */ uint32_t offsetIntoBlock;				// Offset into the block to find the directory entry.
	/* 12 */ uint32_t _unused;					// Unused.
} DirectoryEntryReference;

typedef struct IndexKey {
	/*  0 */ uint64_t value;					// The CRC-64 hashed node path. Ignored for the +1 vertex (assumed to be maximum possible).
	/*  8 */ uint64_t child;					// The block containing the child IndexVertex. Set to 0 for a leaf.
									// All keys in the child should be less than this key.
									// This is the only valid field in the +1 key.
	/* 16 */ DirectoryEntryReference data;				// The directory entry this key refers to.
} IndexKey;

typedef struct IndexVertex {
	/*  0 */ char signature[4];					// Must be ESFS_INDEX_VERTEX_SIGNATURE.
	/*  4 */ uint32_t checksum;					// CRC-32 checksum of IndexVertex.
	/*  8 */ uint16_t offset;					// Offset to the first IndexKey.
	/* 10 */ uint16_t count;					// The number of IndexKeys, (superblock.blockSize - this.offset) / sizeof(IndexKey).
	/* 12 */ uint16_t maxCount;					// The maximum number of IndexKeys that can fit in the vertex.
	/* 14 */ uint16_t _unused0;					// Unused.
	/* 16 */ uint64_t _unused1[2];					// Unused.

#define ESFS_INDEX_KEY_OFFSET (32)
	/* 32 */ IndexKey keys[1];					// There are this.count keys.
} IndexVertex;

typedef struct Superblock {
	/*   0 */ char signature[16];					// The filesystem signature; should be ESFS_SIGNATURE_STRING.
	/*  16 */ char volumeName[ESFS_MAXIMUM_VOLUME_NAME_LENGTH];	// The name of the volume.
	
	/*  48 */ uint16_t requiredReadVersion;				// If this is greater than the driver's version, then the filesystem cannot be read.
	/*  50 */ uint16_t requiredWriteVersion;			// If this is greater than the driver's version, then the filesystem cannot be written.
	
	/*  52 */ uint32_t checksum;					// CRC-32 checksum of Superblock.
	/*  56 */ uint8_t mounted;					// Non-zero to indicate that the volume is mounted, or was not properly unmounted.
	/*  57 */ uint8_t _unused2[7];
	
	/*  64 */ uint64_t blockSize;					// The size of a block on the volume.
	/*  72 */ uint64_t blockCount;					// The number of blocks on the volume.
	/*  80 */ uint64_t blocksUsed;					// The number of blocks that are in use.
	
	/*  88 */ uint32_t blocksPerGroup;				// The number of blocks in a group.
	/*  92 */ uint8_t _unused3[4];
	/*  96 */ uint64_t groupCount;					// The number of groups on the volume.
	/* 104 */ uint64_t blocksPerGroupBlockBitmap;			// The number of blocks used to a store a group's block bitmap.
	/* 112 */ uint64_t gdtFirstBlock;				// The first block in the group descriptor table.
	/* 120 */ uint64_t directoryEntriesPerBlock;			// The number of directory entries in a block.
	/* 128 */ uint64_t _unused0;					// Unused.
	
	/* 136 */ EsUniqueIdentifier identifier;			// The unique identifier for the volume.
	/* 152 */ EsUniqueIdentifier osInstallation;			// The unique identifier of the Essence installation this volume was made for. All zero for a non-installation volume.
	/* 168 */ EsUniqueIdentifier nextIdentifier;			// The identifier to give to the next created file.

	/* 184 */ DirectoryEntryReference kernel;			// The kernel. For convenient access by the bootloader.
	/* 200 */ DirectoryEntryReference root;				// The root directory.

	/* 216 */ uint8_t _unused1[8192 - 216];				// Unused.
} Superblock;

uint64_t EncodeExtent(uint64_t extentStart, uint64_t previousExtentStart, uint64_t extentCount, uint8_t *encode) {
	int64_t relativeStart = (int64_t) (extentStart - previousExtentStart);
	uint64_t absoluteRelativeStart = (uint64_t) (relativeStart < 0 ? -relativeStart : relativeStart);

	uint8_t startBytes = 
		absoluteRelativeStart < 0x80 			? 1
		: absoluteRelativeStart < 0x8000 		? 2
		: absoluteRelativeStart < 0x800000		? 3
		: absoluteRelativeStart < 0x80000000		? 4
		: absoluteRelativeStart < 0x8000000000		? 5
		: absoluteRelativeStart < 0x800000000000	? 6
		: absoluteRelativeStart < 0x80000000000000	? 7
		: 8;
	uint8_t countBytes = 
		extentCount < 0x80 			? 1
		: extentCount < 0x8000 			? 2
		: extentCount < 0x800000		? 3
		: extentCount < 0x80000000		? 4
		: extentCount < 0x8000000000		? 5
		: extentCount < 0x800000000000		? 6
		: extentCount < 0x80000000000000	? 7
		: 8;

	uint64_t position = 0;
	encode[position++] = (startBytes - 1) + ((countBytes - 1) << 3);

	for (int i = 0; i < startBytes; i++, position++) encode[position] = (uint8_t) (relativeStart >> ((startBytes - 1 - i) * 8));
	for (int i = 0; i < countBytes; i++, position++) encode[position] = (uint8_t) (extentCount   >> ((countBytes - 1 - i) * 8));

#if 0
	Log("encode: %d/%d --> ", startBytes, countBytes);

	for (unsigned i = 0; i < position; i++) {
	     Log("%.2X ", (uint32_t) encode[i]);
	}

	Log("\n");
#endif

	return position;
}

bool DecodeExtent(uint64_t *previousExtentStart, uint64_t *extentCount, uint8_t *extents, uint64_t *position, uint64_t end) {
	uint64_t extentStart = 0;
	*extentCount = 0;
	
	if (*position == end) return false;
	uint8_t header = extents[*position];
	*position = *position + 1;

	uint8_t startBytes = ((header >> 0) & 7) + 1;
	uint8_t countBytes = ((header >> 3) & 7) + 1;

	bool negative = false;

	for (uint8_t i = 0; i < startBytes; i++) {
		if (*position == end) return false;
		uint8_t byte = extents[*position];
		if (!i) negative = byte & 0x80;
		extentStart <<= 8;
		extentStart += byte;
		*position = *position + 1;
	}

	for (uint8_t i = 0; i < countBytes; i++) {
		if (*position == end) return false;
		*extentCount = *extentCount << 8;
		*extentCount = *extentCount + extents[*position];
		*position = *position + 1;
	}

	if (negative) {
		for (uint64_t i = startBytes; i < sizeof(uint64_t) / sizeof(uint8_t); i++) {
			extentStart |= (uint64_t) 0xFF << (i * 8);
		}
	}

	*previousExtentStart = *previousExtentStart + extentStart;
	return true;
}

#ifndef KERNEL

uint64_t blockSize;
Superblock superblock;
GroupDescriptor *groupDescriptorTable;
uint64_t copiedCount;

bool ReadBlock(uint64_t block, uint64_t count, void *buffer);
bool WriteBlock(uint64_t block, uint64_t count, void *buffer);
bool WriteBytes(uint64_t offset, uint64_t count, void *buffer);

bool ReadDirectoryEntryReference(DirectoryEntryReference reference, DirectoryEntry *entry) {
	uint8_t buffer[superblock.blockSize];

	if (!ReadBlock(reference.block, 1, buffer)) {
		return false;
	}

	memcpy(entry, buffer + reference.offsetIntoBlock, sizeof(DirectoryEntry));
	return true;
}

bool WriteDirectoryEntryReference(DirectoryEntryReference reference, DirectoryEntry *entry) {
	entry->checksum = 0;
	entry->checksum = CalculateCRC32(entry, sizeof(DirectoryEntry), 0);
	uint8_t buffer[superblock.blockSize];

	if (ReadBlock(reference.block, 1, buffer)) {
		memcpy(buffer + reference.offsetIntoBlock, entry, sizeof(DirectoryEntry));
		return WriteBlock(reference.block, 1, buffer);
	} else {
		return false;
	}
}

Attribute *FindAttribute(DirectoryEntry *entry, uint16_t type) {
	Attribute *attribute = (Attribute *) ((uint8_t *) entry + entry->attributeOffset);
	int count = 0;

	while (attribute->type != type) {
		attribute = (Attribute *) ((uint8_t *) attribute + attribute->size);

		if (count++ == entry->attributeCount) {
			Log("Could not find attribute %d.\n", type);
			EsFSError();
		}
	}

	return attribute;
}

void GenerateUniqueIdentifier(EsUniqueIdentifier *u, bool random) {
	if (random) {
		for (int i = 0; i < 16; i++) {
			u->d[i] = rand();
		}
	} else {
		*u = superblock.nextIdentifier;

		for (int i = 0; i < 16; i++) {
			superblock.nextIdentifier.d[i]++;
			if (superblock.nextIdentifier.d[i]) break;
		}
	}
}

IndexKey *InsertKeyIntoVertex(uint64_t newKey, IndexVertex *vertex) {
	// Find where in this vertex we should insert the key.

	int position;

	for (position = 0; position < vertex->count; position++) {
		if (newKey < ESFS_VERTEX_KEY(vertex, position)->value) {
			break;
		}
	}

	// Insert the key.

	// Log("%d//%d\n", vertex->count, vertex->maxCount);
	assert(vertex->count != vertex->maxCount);
	IndexKey *insertionPosition = ESFS_VERTEX_KEY(vertex, position);
	memmove(insertionPosition + 1, insertionPosition, 
			(vertex->count + 1 - position) * sizeof(IndexKey));
	vertex->count++;
	insertionPosition->value = newKey;

	// Update the checksum.

	vertex->checksum = 0;
	vertex->checksum = CalculateCRC32(vertex, superblock.blockSize, 0);

	return insertionPosition;
}

bool AllocateExtent(uint64_t increaseBlocks, uint64_t *extentStart, uint64_t *extentCount) {
	// Log("used %ld/%ld, need %ld more\n", superblock.blocksUsed, superblock.blockCount, increaseBlocks);

	// Find a group to allocate the next extent from.

	GroupDescriptor *target = NULL;

	{
		for (uint64_t i = 0; !target && i < superblock.groupCount; i++) {
			GroupDescriptor *group = groupDescriptorTable + i;
			if (!group->blocksUsed) group->largestExtent = superblock.blocksPerGroup - superblock.blocksPerGroupBlockBitmap;
			if (group->largestExtent >= increaseBlocks) target = group;
		}

		for (uint64_t i = 0; !target && i < superblock.groupCount; i++) {
			GroupDescriptor *group = groupDescriptorTable + i;
			if (superblock.blocksPerGroup - group->blocksUsed >= increaseBlocks) target = group;
		}

		for (uint64_t i = 0; !target && i < superblock.groupCount; i++) {
			GroupDescriptor *group = groupDescriptorTable + i;
			if (superblock.blocksPerGroup != group->blocksUsed) target = group;
		}
	}

	if (!target) {
		Log("Out of space.\n");
		EsFSError();
	}

	// Load the bitmap, find the largest extent, and mark it as in use.

	uint8_t bitmap[superblock.blocksPerGroupBlockBitmap * superblock.blockSize];

	{
		if (target->blockBitmap) {
			if (!ReadBlock(target->blockBitmap, superblock.blocksPerGroupBlockBitmap, bitmap)) {
				return false;
			}
		} else {
			memset(bitmap, 0, superblock.blocksPerGroupBlockBitmap * superblock.blockSize);
			for (uint64_t i = 0; i < superblock.blocksPerGroupBlockBitmap; i++) bitmap[i / 8] |= 1 << (i % 8);
			target->blockBitmap = superblock.blocksPerGroup * (target - groupDescriptorTable);
			target->blocksUsed = superblock.blocksPerGroupBlockBitmap;
		}

		uint64_t largestExtentStart = 0, largestExtentCount = 0, i = 0;

		while (i < superblock.blocksPerGroup) {
			if (bitmap[i / 8] & (1 << (i % 8))) {
				i++;
			} else {
				uint64_t start = i, count = 0;

				while (i < superblock.blocksPerGroup) {
					if (bitmap[i / 8] & (1 << (i % 8))) break;
					else count++, i++;
				}

				if (largestExtentCount < count) {
					largestExtentStart = start;
					largestExtentCount = count;
				}
			}
		}

		assert(largestExtentCount == target->largestExtent);

		*extentStart = largestExtentStart;
		*extentCount = largestExtentCount;

		if (*extentCount > increaseBlocks) {
			*extentCount = increaseBlocks;
		}

		for (uint64_t i = *extentStart; i < *extentStart + *extentCount; i++) {
			bitmap[i / 8] |= 1 << (i % 8);
		}

		{
			uint64_t largestExtentCount = 0, i = 0;

			while (i < superblock.blocksPerGroup) {
				if (bitmap[i / 8] & (1 << (i % 8))) {
					i++;
				} else {
					uint64_t count = 0;

					while (i < superblock.blocksPerGroup) {
						if (bitmap[i / 8] & (1 << (i % 8))) break;
						else count++, i++;
					}

					if (largestExtentCount < count) {
						largestExtentCount = count;
					}
				}
			}

			target->blocksUsed += *extentCount;
			target->largestExtent = largestExtentCount;

			assert(superblock.blocksPerGroup == target->blocksUsed || target->largestExtent);
		}

		target->bitmapChecksum = CalculateCRC32(bitmap, sizeof(bitmap), 0);
		target->checksum = 0;
		target->checksum = CalculateCRC32(target, sizeof(GroupDescriptor), 0);

		if (!WriteBlock(target->blockBitmap, superblock.blocksPerGroupBlockBitmap, bitmap)) {
			return false;
		}
	}

	*extentStart = *extentStart + (target - groupDescriptorTable) * superblock.blocksPerGroup;
	superblock.blocksUsed += *extentCount;
	// Log("allocate extent: %ld -> %ld (for %ld)\n", extentStart, extentStart + extentCount, increaseBlocks);
	return true;
}

bool AccessNode(DirectoryEntry *node, void *buffer, uint64_t offsetIntoFile, uint64_t totalCount, DirectoryEntryReference *reference, bool read) {
	if (!totalCount) return true;
	AttributeData *dataAttribute = (AttributeData *) FindAttribute(node, ESFS_ATTRIBUTE_DATA);

	if (dataAttribute->indirection == ESFS_INDIRECTION_DIRECT && read) {
		memcpy(buffer, dataAttribute->data + offsetIntoFile, totalCount);
		return true;
	} else if (dataAttribute->indirection == ESFS_INDIRECTION_DIRECT && !read) {
		assert(!reference);
		memcpy(dataAttribute->data + offsetIntoFile, buffer, totalCount);
		return true;
	}

	assert(dataAttribute->indirection == ESFS_INDIRECTION_L1);

	int decoded = -1;

	// Log("\twrite %ld bytes at %ld\n", totalCount, offsetIntoFile);

	next:;
	uint64_t block = offsetIntoFile / superblock.blockSize;
	uint64_t offset = offsetIntoFile % superblock.blockSize;
	uint64_t count = superblock.blockSize - offset;
	if (totalCount < count) count = totalCount;

	// Log("block: %ld, offset: %ld, count: %ld\n", block, offset, count);

	// Find the extent.

	uint8_t *extents = ((uint8_t *) dataAttribute + dataAttribute->dataOffset);

	{
		uint64_t position = 0, blockInFile = 0, extentStart = 0;
		assert(dataAttribute->count || !node->fileSize);

		bool found = false;

		for (uint64_t i = 0; i < dataAttribute->count; i++) {
			uint64_t extentCount = 0;
			DecodeExtent(&extentStart, &extentCount, extents, &position, dataAttribute->size - dataAttribute->dataOffset);
			if (decoded < (int) i) {
				decoded = i;
			}

			if (blockInFile + extentCount > block) {
				uint64_t offsetIntoExtent = block - blockInFile;
				block = extentStart + offsetIntoExtent;
				found = true;
				break;
			}

			blockInFile += extentCount;
		}

		assert(found);
	}

	uint8_t blockBuffer[superblock.blockSize];

	if (read || count != superblock.blockSize) {
		if (!ReadBlock(block, 1, blockBuffer)) {
			return false;
		}
	}

	if (read) {
		memcpy(buffer, blockBuffer + offset, count);
	} else {
		memcpy(blockBuffer + offset, buffer, count);

		if (!WriteBlock(block, 1, blockBuffer)) {
			return false;
		}
	}

	if (reference) {
		reference->block = block;
		reference->offsetIntoBlock = offset;
	}

	totalCount -= count;

	if (totalCount) {
		offsetIntoFile += count;
		buffer = (uint8_t *) buffer + count;
		goto next;
	}

	return true;
}

bool ResizeNode(DirectoryEntry *entry, uint64_t newSize) {
	assert(newSize >= entry->fileSize);

	AttributeData *dataAttribute = (AttributeData *) FindAttribute(entry, ESFS_ATTRIBUTE_DATA);

	if (newSize < (uint64_t) (dataAttribute->size - dataAttribute->dataOffset) && entry->nodeType == ESFS_NODE_TYPE_FILE) {
		dataAttribute->indirection = ESFS_INDIRECTION_DIRECT;
		dataAttribute->count = entry->fileSize = newSize;
		return true;
	}

	// Log("\tresize to %lu\n", newSize);

	dataAttribute->indirection = ESFS_INDIRECTION_L1;

	uint64_t oldSize = entry->fileSize;
	uint64_t oldBlocks = (oldSize + superblock.blockSize - 1) / superblock.blockSize;
	uint64_t newBlocks = (newSize + superblock.blockSize - 1) / superblock.blockSize;

	entry->fileSize = newSize;

	if (oldBlocks == newBlocks) {
		// Do nothing.
	} else if (oldBlocks < newBlocks) {
		uint64_t increaseBlocks = newBlocks - oldBlocks;
		uint64_t previousExtentStart = 0, previousExtentCount = 0, previousExtentStart2 = 0;

		uint8_t *extents = ((uint8_t *) dataAttribute + dataAttribute->dataOffset);
		uint64_t offsetIntoExtentList = 0;
		uint64_t previousOffsetIntoExtentList = 0;

		for (uint64_t i = 0; i < dataAttribute->count; i++) {
			previousOffsetIntoExtentList = offsetIntoExtentList;
			previousExtentStart2 = previousExtentStart;
			DecodeExtent(&previousExtentStart, &previousExtentCount, extents, &offsetIntoExtentList, dataAttribute->size - dataAttribute->dataOffset);
			// Log("%ld/%ld/%ld\n", previousExtentStart, extentCount, offsetIntoExtentList);
			assert(previousExtentStart < superblock.blockCount);
		}

		while (increaseBlocks) {
			uint64_t extentStart, extentCount, encodedLength;
			uint8_t encode[32];

			if (!AllocateExtent(increaseBlocks, &extentStart, &extentCount)) {
				return false;
			}

			if (extentStart == previousExtentStart + previousExtentCount) {
				dataAttribute->count--;
				offsetIntoExtentList = previousOffsetIntoExtentList;
				encodedLength = EncodeExtent(previousExtentStart, previousExtentStart2, extentCount + previousExtentCount, encode);
			} else {
				encodedLength = EncodeExtent(extentStart, previousExtentStart, extentCount, encode);
			}

			// Log("\t@%ld alloc %ld, %ld\n", offsetIntoExtentList, extentStart, extentCount);

			// Log("%ld vs %ld\n", offsetIntoExtentList + encodedLength, (uint64_t) (dataAttribute->size - dataAttribute->dataOffset));

			if (offsetIntoExtentList + encodedLength > (uint64_t) (dataAttribute->size - dataAttribute->dataOffset)) {
				Log("Unimplemented - indirection past L1.\n");
				EsFSError();
			}

			memcpy(extents + offsetIntoExtentList, encode, encodedLength);
			offsetIntoExtentList += encodedLength;
			increaseBlocks -= extentCount;
			dataAttribute->count++;
			previousExtentStart = extentStart;
		}
	} else {
		Log("Unimplemented - node truncation.\n");
		EsFSError();
	}

	return true;
}

#if 0
void PrintTree(uint64_t block, int indent = 2, uint64_t lowerThan = -1) {
	if (!block) return;

	uint8_t buffer[superblock.blockSize];
	ReadBlock(block, 1, buffer);
	IndexVertex *node = (IndexVertex *) buffer;
	const char *spaces = "|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   ";

#ifndef VALIDATE_TREE_ONLY
	Log("%.*snode with %d+1 keys [%p]\n", indent, spaces, node->count, node);
#endif

	for (uint64_t i = 0; i <= node->count; i++) {
		if (i && i != node->count && node->keys[i].value <= node->keys[i - 1].value) {
			Log("%.*s %lu VIOLATION [1]\n", indent, spaces, i);
			assert(false);
		}

		uint64_t next = lowerThan;

		if (i == node->count) {
#ifndef VALIDATE_TREE_ONLY
			Log("%.*s %lu last key\n", indent, spaces, i);
#endif
		} else {
			if (node->keys[i].value >= lowerThan) {
				Log("%.*s %lu VIOLATION [2]\n", indent, spaces, i);
				assert(false);
			}

#ifndef VALIDATE_TREE_ONLY
			Log("%.*s %lu key = %lu\n", indent, spaces, i, node->keys[i].value);
#endif
			next = node->keys[i].value;
		}

		PrintTree(node->keys[i].child, indent + 4, next);
	}
}
#endif

void NewDirectoryEntry(DirectoryEntry *entry, uint8_t nodeType, EsUniqueIdentifier parentUID, const char *name) {
	memcpy(entry->signature, ESFS_DIRECTORY_ENTRY_SIGNATURE, 8);
	GenerateUniqueIdentifier(&entry->identifier, false);
	entry->attributeOffset = ESFS_ATTRIBUTE_OFFSET;
	entry->nodeType = nodeType; 
	entry->parent = parentUID;

	uint8_t *position = (uint8_t *) entry + entry->attributeOffset;
	size_t newFilenameSize = ((strlen(name) + ESFS_FILENAME_HEADER_SIZE - 1) & ~7) + 8; // Size of name + size of header, rounded up to the nearest 8 bytes.

	if (nodeType == ESFS_NODE_TYPE_DIRECTORY) {
		AttributeDirectory *directory = (AttributeDirectory *) position;
		directory->type = ESFS_ATTRIBUTE_DIRECTORY;
		directory->size = sizeof(AttributeDirectory);
		directory->indexRootBlock = 0;
		directory->totalSize = 0;
		entry->attributeCount++;
		position += directory->size;
	}

	AttributeData *data = (AttributeData *) position;
	data->type = ESFS_ATTRIBUTE_DATA;
	data->size = sizeof(DirectoryEntry) - newFilenameSize - (position - (uint8_t *) entry);
	data->indirection = nodeType == ESFS_NODE_TYPE_DIRECTORY ? ESFS_INDIRECTION_L1 : ESFS_INDIRECTION_DIRECT;
	data->dataOffset = ESFS_DATA_OFFSET;
	entry->attributeCount++;
	position += data->size;

	AttributeFilename *filename = (AttributeFilename *) position;
	filename->type = ESFS_ATTRIBUTE_FILENAME;
	filename->size = newFilenameSize;
	filename->length = strlen(name);
	memcpy(filename->filename, name, filename->length);
	entry->attributeCount++;
	position += filename->size;

	assert(position == (uint8_t *) (entry + 1));
	entry->checksum = 0;
	entry->checksum = CalculateCRC32(entry, sizeof(DirectoryEntry), 0);
}

bool AddNode(const char *name, uint8_t nodeType, DirectoryEntry *outputEntry, DirectoryEntryReference *outputReference, 
		DirectoryEntryReference directoryReference) {
	// Log("add %s to %s\n", name, path);

	// Step 1: Resize the directory so that it can fit another directory entry.

	DirectoryEntry directory; 

	if (!ReadDirectoryEntryReference(directoryReference, &directory)) return false;
	AttributeData *dataAttribute = (AttributeData *) FindAttribute(&directory, ESFS_ATTRIBUTE_DATA);
	AttributeDirectory *directoryAttribute = (AttributeDirectory *) FindAttribute(&directory, ESFS_ATTRIBUTE_DIRECTORY);

	{

		assert(dataAttribute->indirection == ESFS_INDIRECTION_L1);

		if (!(directoryAttribute->childNodes % superblock.directoryEntriesPerBlock)) {
			// Log("increasing directory to fit %ld entries\n========={\n", (directory.fileSize + superblock.blockSize) / sizeof(DirectoryEntry));
			if (!ResizeNode(&directory, directory.fileSize + superblock.blockSize)) return false;
			// Log("========}\n");
		}

		directoryAttribute->childNodes++;

		if (!WriteDirectoryEntryReference(directoryReference, &directory)) {
			return false;
		}
	}

	// Step 2: Create the directory entry, and write it to the directory.

	DirectoryEntryReference reference = {};
	DirectoryEntry entry = {};

	{
		NewDirectoryEntry(&entry, nodeType, directory.identifier, name);
		// Log("\tchild nodes: %ld\n", directoryAttribute->childNodes);

		if (!AccessNode(&directory, &entry, (directoryAttribute->childNodes - 1) * sizeof(DirectoryEntry), sizeof(DirectoryEntry), &reference, false)) {
			return false;
		}
	}

	// Step 3: Add the node into the index. 

	uint64_t newKey = CalculateCRC64(name, strlen(name), 0);
	// Log("adding file '%s' to index...\n", name);

	{
		// Find the leaf to insert the key into.

		uint8_t buffer[superblock.blockSize];
		memset(buffer, 0, superblock.blockSize);
		IndexVertex *vertex = (IndexVertex *) buffer;
		uint64_t depth = 0, blocks[ESFS_INDEX_MAX_DEPTH] = { directoryAttribute->indexRootBlock };

		if (blocks[0] == 0) {
			// Directory is empty - create the root vertex.

			uint64_t _unused;

			if (!AllocateExtent(1, &directoryAttribute->indexRootBlock, &_unused)) {
				return false;
			}

			blocks[0] = directoryAttribute->indexRootBlock;
			vertex->maxCount = (superblock.blockSize - ESFS_INDEX_KEY_OFFSET) / sizeof(IndexKey) - 1 /* +1 key */;
			vertex->offset = ESFS_INDEX_KEY_OFFSET;
			memcpy(vertex->signature, ESFS_INDEX_VERTEX_SIGNATURE, 4);
			// Log("rootBlock = %ld for %s\n", directoryAttribute->indexRootBlock, path);
		} else {
			if (!ReadBlock(blocks[0], 1, vertex)) {
				return false;
			}
			// Log("start = %ld for %s\n", blocks[0], path);
		}

		while (true) {
			for (int i = 0; i < vertex->count; i++) {
				if (ESFS_VERTEX_KEY(vertex, i)->value == newKey) {
					// The key is already in the tree.
					Log("The file already exists.");
					EsFSError();
				}
			}

			for (int i = 0; i <= vertex->count; i++) {
				IndexKey *key = ESFS_VERTEX_KEY(vertex, i);

				if ((i == vertex->count || newKey < key->value) && key->child) {
					blocks[++depth] = key->child;

					if (!ReadBlock(key->child, 1, vertex)) {
						return false;
					}

					goto next;
				}
			}

			break;
			next:;	
		}

		// Insert the key into the vertex.

		InsertKeyIntoVertex(newKey, vertex)->data = reference;

		// While the vertex is full...

		assert(vertex->count <= vertex->maxCount);

		while (vertex->count == vertex->maxCount) {
			// Log("\tsplit!\n");

			char _buffer0[superblock.blockSize];
			char _buffer1[superblock.blockSize];
			memset(_buffer0, 0, superblock.blockSize);
			memset(_buffer1, 0, superblock.blockSize);

			// Create a new sibling.

			uint64_t siblingBlock = 0, _unused;
			if (!AllocateExtent(1, &siblingBlock, &_unused)) return false;
			IndexVertex *sibling = (IndexVertex *) _buffer0;
			sibling->maxCount = (superblock.blockSize - ESFS_INDEX_KEY_OFFSET) / sizeof(IndexKey) - 1 /* +1 key */;
			sibling->offset = ESFS_INDEX_KEY_OFFSET;
			memcpy(sibling->signature, ESFS_INDEX_VERTEX_SIGNATURE, 4);

			// Load the parent vertex.

			bool newRoot = !depth;
			IndexVertex *parent = (IndexVertex *) _buffer1;

			if (newRoot) {
				// Create a new root block.

				// Log("\t(new root)\n");

				blocks[1] = blocks[0];
				depth++;

				uint64_t _unused;
				if (!AllocateExtent(1, &blocks[0], &_unused)) return false;

				parent->maxCount = (superblock.blockSize - ESFS_INDEX_KEY_OFFSET) / sizeof(IndexKey) - 1 /* +1 key */;
				parent->offset = ESFS_INDEX_KEY_OFFSET;
				memcpy(parent->signature, ESFS_INDEX_VERTEX_SIGNATURE, 4);

				// The superblock points to the new root, and the +1 key of the new root points to the old root.
				// It has no other keys yet.

				parent->keys[0].child = blocks[1];
				directoryAttribute->indexRootBlock = blocks[0];
			} else {
				if (!ReadBlock(blocks[depth - 1], 1, parent)) {
					return false;
				}
			}

			IndexKey *parentKeys = (IndexKey *) ((uint8_t *) parent + parent->offset);
			IndexKey *vertexKeys = (IndexKey *) ((uint8_t *) vertex + vertex->offset);
			IndexKey *siblingKeys = (IndexKey *) ((uint8_t *) sibling + sibling->offset);

			// Change the link to this vertex to point to the sibling.

			int found = 0;

			for (uint64_t i = 0; i <= parent->count; i++) {
				if (parentKeys[i].child == blocks[depth]) {
					parentKeys[i].child = siblingBlock;
					found++;
				}
			}

			assert(found == 1);

			// Move the median key to the parent.
			// If this makes the parent full we'll fix it next iteration.

			uint64_t median = (vertex->maxCount - 1) / 2; 
			uint64_t newKey = vertexKeys[median].value;

			for (uint64_t i = 0; i <= parent->count; i++) {
				if (i == parent->count || newKey < parentKeys[i].value) {
					memmove(parentKeys + i + 1, parentKeys + i, (++parent->count - i) * sizeof(IndexKey));
					parentKeys[i].value = newKey;
					parentKeys[i].data = vertexKeys[median].data;
					parentKeys[i].child = blocks[depth];
					break;
				}
			}

			// Move all keys above the median key to the new sibling.
			sibling->count = vertex->count - median /*Kept in the node*/ - 1 /*Added to the parent*/;
			vertex->count = median; // The data on the median key becomes the +1 key's data.
			memcpy(siblingKeys, vertexKeys + median + 1, (sibling->count + 1) * sizeof(IndexKey));

			// Write the blocks.

			sibling->checksum = 0; sibling->checksum = CalculateCRC32(sibling, superblock.blockSize, 0);
			vertex->checksum = 0; vertex->checksum = CalculateCRC32(vertex, superblock.blockSize, 0);
			if (!WriteBlock(siblingBlock, 1, sibling)) return false;
			if (!WriteBlock(blocks[depth], 1, vertex)) return false;

			// Check if the parent vertex is full.

			memcpy(vertex, parent, superblock.blockSize);
			depth--;
		}

		// Write the block.

		vertex->checksum = 0; vertex->checksum = CalculateCRC32(vertex, superblock.blockSize, 0);
		if (!WriteBlock(blocks[depth], 1, vertex)) return false;
	}

	if (outputEntry) *outputEntry = entry;
	if (outputReference) *outputReference = reference;

	// PrintTree(directoryAttribute->indexRootBlock);
	if (!WriteDirectoryEntryReference(directoryReference, &directory)) {
		return false;
	}

	return true;
}

bool MountVolume() {
	// Read the superblock.
	blockSize = ESFS_BOOT_SUPER_BLOCK_SIZE;

	if (!ReadBlock(1, 1, &superblock)) {
		return false;
	}

	if (superblock.mounted) {
		Log("EsFS: Volume not unmounted, exiting...\n");
		EsFSError();
	}

	superblock.mounted = 1;

	if (!WriteBlock(1, 1, &superblock)) {
		return false;
	}

	blockSize = superblock.blockSize;

	// Read the group descriptor table.
	groupDescriptorTable = (GroupDescriptor *) malloc(superblock.groupCount * sizeof(GroupDescriptor) + superblock.blockSize - 1);

	if (!ReadBlock(superblock.gdtFirstBlock, (superblock.groupCount * sizeof(GroupDescriptor) + superblock.blockSize - 1) / superblock.blockSize, groupDescriptorTable)) {
		return false;
	}

	return true;
}

void UnmountVolume() {
	WriteBlock(superblock.gdtFirstBlock, (superblock.groupCount * sizeof(GroupDescriptor) + superblock.blockSize - 1) / superblock.blockSize, groupDescriptorTable);
	blockSize = ESFS_BOOT_SUPER_BLOCK_SIZE;
	superblock.mounted = 0;
	superblock.checksum = 0;
	superblock.checksum = CalculateCRC32(&superblock, sizeof(Superblock), 0);
	WriteBlock(1, 1, &superblock); 
	free(groupDescriptorTable);
}

bool FindNode(const char *cName, DirectoryEntry *node, DirectoryEntryReference directoryReference) {
	DirectoryEntry directory; 
	if (!ReadDirectoryEntryReference(directoryReference, &directory)) return false;
	AttributeDirectory *directoryAttribute = (AttributeDirectory *) FindAttribute(&directory, ESFS_ATTRIBUTE_DIRECTORY);

	for (uintptr_t i = 0; i < directoryAttribute->childNodes; i++) {
		if (!AccessNode(&directory, node, sizeof(DirectoryEntry) * i, sizeof(DirectoryEntry), NULL, true)) {
			return false;
		}

		AttributeFilename *filename = (AttributeFilename *) FindAttribute(node, ESFS_ATTRIBUTE_FILENAME);

		if (filename->length == strlen(cName) && 0 == memcmp(filename->filename, cName, filename->length)) {
			return true;
		}
	}

	Log("Could not find '%s'.\n", cName);
	return false;
}

#if 0
void Read(char *target, DirectoryEntryReference parentDirectory) {
	DirectoryEntryReference outputReference;
	DirectoryEntry entry;
	if (!FindNode(target, &entry, parentDirectory)) return;
	char *data = (char *) malloc(entry.fileSize);
	AccessNode(&entry, data, 0, entry.fileSize, &outputReference, true);
	fwrite(data, 1, entry.fileSize, stdout);
}
#endif

#ifndef INSTALLER
typedef struct ImportNode {
	const char *name, *path;
	struct ImportNode *children;
	bool isFile;
} ImportNode;

int64_t Import(ImportNode node, DirectoryEntryReference parentDirectory) {
	uint64_t totalSize = 0;

	for (uintptr_t i = 0; i < arrlenu(node.children); i++) {
		if (node.children[i].isFile) {
			size_t fileLength;
			void *data = LoadFile(node.children[i].path, &fileLength);

			if (!data) {
				Log("Warning: Could not read file '%s'!\n", node.children[i].path);
			} else {
				copiedCount += fileLength;

				DirectoryEntryReference reference;
				DirectoryEntry entry;

				if (!AddNode(node.children[i].name, ESFS_NODE_TYPE_FILE, &entry, &reference, parentDirectory)) {
					return -1;
				}

				if (!ResizeNode(&entry, fileLength)) {
					return -1;
				}

				totalSize += fileLength;

				if (!AccessNode(&entry, data, 0, fileLength, NULL, false)) {
					return -1;
				}

				if (!WriteDirectoryEntryReference(reference, &entry)) {
					return -1;
				}

				free(data);
			}
		} else {
			DirectoryEntryReference reference;
			if (!AddNode(node.children[i].name, ESFS_NODE_TYPE_DIRECTORY, NULL, &reference, parentDirectory)) return -1;
			int64_t size = Import(node.children[i], reference);
			if (size == -1) return -1;
			DirectoryEntry directory; 
			if (!ReadDirectoryEntryReference(reference, &directory)) return -1;
			AttributeDirectory *directoryAttribute = (AttributeDirectory *) FindAttribute(&directory, ESFS_ATTRIBUTE_DIRECTORY);
			directoryAttribute->totalSize = size;
			if (!WriteDirectoryEntryReference(reference, &directory)) return -1;
			totalSize += size;
		}
	}

	return totalSize;
}
#endif

bool Format(uint64_t driveSize, const char *volumeName, EsUniqueIdentifier osInstallation,
		void *kernel, size_t kernelBytes) {
	assert(sizeof(Superblock) == 8192);

	if (driveSize < ESFS_DRIVE_MINIMUM_SIZE) {
		Log("Error: Cannot create a drive of %d bytes (too small).\n", (int) driveSize);
		EsFSError();
	}

	if (strlen(volumeName) > ESFS_MAXIMUM_VOLUME_NAME_LENGTH) {
		Log("Error: Volume name '%s' is too long; must be <= %d bytes.\n", volumeName, (int) ESFS_MAXIMUM_VOLUME_NAME_LENGTH);
		EsFSError();
	}

	// Format the volume.

	{
		memcpy(superblock.signature, ESFS_SIGNATURE_STRING, 16);
		memcpy(superblock.volumeName, volumeName, strlen(volumeName));

		superblock.requiredReadVersion = ESFS_DRIVER_VERSION;
		superblock.requiredWriteVersion = ESFS_DRIVER_VERSION;

		if (driveSize < 2048ll * 1024 * 1024) { // < 2GB
			superblock.blockSize = 2048; // Must be >= sizeof(DirectoryEntry).
		} else if (driveSize < 2ll * 1024 * 1024 * 1024 * 1024) { // < 2TB
			superblock.blockSize = 4096;
		} else if (driveSize < 256ll * 1024 * 1024 * 1024 * 1024) { // < 256TB
			superblock.blockSize = 8192;
		} else {
			superblock.blockSize = 16384;
		}

		superblock.blockCount = driveSize / superblock.blockSize;
		superblock.blocksPerGroup = 32768;
		if (superblock.blockCount < superblock.blocksPerGroup) superblock.blocksPerGroup = superblock.blockCount / 2;
		superblock.groupCount = (superblock.blockCount + superblock.blocksPerGroup - 1) / superblock.blocksPerGroup;
		superblock.blocksPerGroupBlockBitmap = ((superblock.blocksPerGroup + 7) / 8 + superblock.blockSize - 1) / superblock.blockSize;
		superblock.directoryEntriesPerBlock = superblock.blockSize / sizeof(DirectoryEntry);

		uint64_t blockGDT = ESFS_BOOT_SUPER_BLOCK_SIZE * 2 / superblock.blockSize + 1;
		uint64_t blockGroup0Bitmap = blockGDT + (superblock.groupCount * sizeof(GroupDescriptor) + superblock.blockSize - 1) / superblock.blockSize;
		uint64_t blockGroupLastBitmap = blockGroup0Bitmap + (superblock.groupCount * sizeof(GroupDescriptor) + superblock.blockSize - 1) / superblock.blockSize;
		uint64_t blockCoreNodes = blockGroupLastBitmap + superblock.blocksPerGroupBlockBitmap;
		uint64_t end = blockCoreNodes + ((ESFS_CORE_NODE_COUNT + superblock.directoryEntriesPerBlock - 1) / superblock.directoryEntriesPerBlock);

		superblock.blocksUsed = end;
		superblock.gdtFirstBlock = blockGDT;

		GenerateUniqueIdentifier(&superblock.identifier, true);
		superblock.osInstallation = osInstallation;

		DirectoryEntry coreNodes[ESFS_CORE_NODE_COUNT] = {};

		superblock.root.block =              (blockCoreNodes * superblock.blockSize + sizeof(DirectoryEntry) * ESFS_CORE_NODE_ROOT)   / superblock.blockSize;
		superblock.root.offsetIntoBlock =    (blockCoreNodes * superblock.blockSize + sizeof(DirectoryEntry) * ESFS_CORE_NODE_ROOT)   % superblock.blockSize;
		superblock.kernel.block =            (blockCoreNodes * superblock.blockSize + sizeof(DirectoryEntry) * ESFS_CORE_NODE_KERNEL) / superblock.blockSize;
		superblock.kernel.offsetIntoBlock =  (blockCoreNodes * superblock.blockSize + sizeof(DirectoryEntry) * ESFS_CORE_NODE_KERNEL) % superblock.blockSize;

		{
			// Root directory.
			DirectoryEntry *entry = coreNodes + ESFS_CORE_NODE_ROOT;
			memcpy(entry->signature, ESFS_DIRECTORY_ENTRY_SIGNATURE, 8);
			GenerateUniqueIdentifier(&entry->identifier, false);
			entry->attributeOffset = ESFS_ATTRIBUTE_OFFSET;
			entry->nodeType = ESFS_NODE_TYPE_DIRECTORY;
			entry->attributeCount = 2;
			AttributeDirectory *directory = (AttributeDirectory *) entry->attributes;
			directory->type = ESFS_ATTRIBUTE_DIRECTORY;
			directory->size = sizeof(AttributeDirectory);
			AttributeData *data = (AttributeData *) ((uint8_t *) directory + directory->size);
			data->type = ESFS_ATTRIBUTE_DATA;
			data->size = sizeof(DirectoryEntry) - ESFS_ATTRIBUTE_OFFSET - directory->size;
			data->indirection = ESFS_INDIRECTION_L1;
			data->dataOffset = ESFS_ATTRIBUTE_OFFSET;
			entry->checksum = CalculateCRC32(entry, sizeof(DirectoryEntry), 0);
		}

		if (!WriteBytes(blockCoreNodes * superblock.blockSize, sizeof(coreNodes), &coreNodes)) {
			return false;
		}

		superblock.checksum = CalculateCRC32(&superblock, sizeof(Superblock), 0);

		if (!WriteBytes(ESFS_BOOT_SUPER_BLOCK_SIZE, ESFS_BOOT_SUPER_BLOCK_SIZE, &superblock)) {
			return false;
		}

		{
			GroupDescriptor *buffer = (GroupDescriptor *) malloc(superblock.groupCount * sizeof(GroupDescriptor));
			memset(buffer, 0, superblock.groupCount * sizeof(GroupDescriptor));

			for (uintptr_t i = 0; i < superblock.groupCount; i++) {
				memcpy(buffer[i].signature, ESFS_GROUP_DESCRIPTOR_SIGNATURE, 4);
				buffer[i].largestExtent = superblock.blocksPerGroup - superblock.blocksPerGroupBlockBitmap;
				uint8_t bitmap[superblock.blocksPerGroupBlockBitmap * superblock.blockSize];

				if (i == 0) {
					memset(bitmap, 0, superblock.blocksPerGroupBlockBitmap * superblock.blockSize);
					for (uint64_t i = 0; i < superblock.blocksUsed; i++) bitmap[i / 8] |= 1 << (i % 8);
					buffer[i].blocksUsed = superblock.blocksUsed;
					buffer[i].blockBitmap = blockGroup0Bitmap;
					buffer[i].bitmapChecksum = CalculateCRC32(bitmap, sizeof(bitmap), 0);
					buffer[i].largestExtent = superblock.blocksPerGroup - superblock.blocksUsed;

					if (!WriteBytes(blockGroup0Bitmap * superblock.blockSize, sizeof(bitmap), &bitmap)) {
						return false;
					}
				} else if (i == superblock.groupCount - 1) {
					// Mark the blocks that go past the end of the file system in the last block group as allocated.
					// TODO Make sure these blocks aren't deallocated by any future file system checker tools!
					uint64_t overflow = superblock.blocksPerGroup * superblock.groupCount - superblock.blockCount;
					assert(overflow < superblock.blocksPerGroup);

					memset(bitmap, 0, superblock.blocksPerGroupBlockBitmap * superblock.blockSize);
					for (uint64_t i = superblock.blocksPerGroup - overflow; i < superblock.blocksPerGroup; i++) bitmap[i / 8] |= 1 << (i % 8);
					buffer[i].blocksUsed = overflow;
					buffer[i].blockBitmap = blockGroupLastBitmap;
					buffer[i].bitmapChecksum = CalculateCRC32(bitmap, sizeof(bitmap), 0);
					buffer[i].largestExtent = superblock.blocksPerGroup - overflow;

					if (!WriteBytes(blockGroupLastBitmap * superblock.blockSize, sizeof(bitmap), &bitmap)) {
						return false;
					}
				}

				buffer[i].checksum = CalculateCRC32(buffer + i, sizeof(GroupDescriptor), 0);
			}

			if (!WriteBytes(superblock.gdtFirstBlock * superblock.blockSize, superblock.groupCount * sizeof(GroupDescriptor), buffer)) {
				return false;
			}

			free(buffer);
		}
	}

	// Add the kernel.

	if (MountVolume()) {
		DirectoryEntryReference reference = superblock.kernel;
		DirectoryEntry entry;
		EsUniqueIdentifier unused = {};

		NewDirectoryEntry(&entry, ESFS_NODE_TYPE_FILE, unused, "Kernel");

		if (WriteDirectoryEntryReference(reference, &entry)) {
			if (ResizeNode(&entry, kernelBytes)) {
				if (AccessNode(&entry, kernel, 0, kernelBytes, NULL, false)) {
					WriteDirectoryEntryReference(reference, &entry);
				} else {
					return false;
				}
			} else {
				return false;
			}
		} else {
			return false;
		}

		UnmountVolume();
	} else {
		return false;
	}

	return true;
}

#endif