/*
 * Copyright 2009, Michael Lotz, mmlr@mlotz.ch. All rights reserved.
 * Copyright 2007-2013, Axel Dörfler, axeld@pinc-software.de.
 *
 * Distributed under the terms of the MIT License.
 */


#include "gpt.h"

#include <KernelExport.h>
#include <disk_device_manager/ddm_modules.h>
#include <disk_device_types.h>
#ifdef _BOOT_MODE
#	include <boot/partitions.h>
#else
#	include <DiskDeviceTypes.h>
#	include "PartitionLocker.h"
#endif
#include <util/kernel_cpp.h>

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

#ifndef _BOOT_MODE
#include "uuid.h"
#endif

#include "Header.h"
#include "utility.h"


#define TRACE_EFI_GPT
#ifdef TRACE_EFI_GPT
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif


#define EFI_PARTITION_MODULE_NAME "partitioning_systems/efi_gpt/v1"


#ifndef _BOOT_MODE
static off_t
block_align(partition_data* partition, off_t offset, bool upwards)
{
	// Take HDs into account that hide the fact they are using a
	// block size of 4096 bytes, and round to that.
	uint32 blockSize = max_c(partition->block_size, 4096);
	if (upwards)
		return ((offset + blockSize - 1) / blockSize) * blockSize;

	return (offset / blockSize) * blockSize;
}
#endif // !_BOOT_MODE


//	#pragma mark - public module interface


static status_t
efi_gpt_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		case B_MODULE_UNINIT:
			return B_OK;
	}

	return B_ERROR;
}


static float
efi_gpt_identify_partition(int fd, partition_data* partition, void** _cookie)
{
	EFI::Header* header = new (std::nothrow) EFI::Header(fd,
		(partition->size - 1) / partition->block_size, partition->block_size);
	status_t status = header->InitCheck();
	if (status != B_OK) {
		delete header;
		return -1;
	}

	*_cookie = header;
	if (header->IsDirty()) {
		// Either the main or the backup table is missing, it looks like someone
		// tried to erase the GPT with something else. Let's lower the priority,
		// so that other partitioning systems which use either only the start or
		// only the end of the drive, have a chance to run instead.
		return 0.75;
	}
	return 0.96;
		// This must be higher as Intel partitioning, as EFI can contain this
		// partitioning for compatibility
}


static status_t
efi_gpt_scan_partition(int fd, partition_data* partition, void* _cookie)
{
	TRACE(("efi_gpt_scan_partition(cookie = %p)\n", _cookie));
	EFI::Header* header = (EFI::Header*)_cookie;

	partition->status = B_PARTITION_VALID;
	partition->flags |= B_PARTITION_PARTITIONING_SYSTEM;
	partition->content_size = partition->size;
	partition->content_cookie = header;

	// scan all children

	uint32 index = 0;

	for (uint32 i = 0; i < header->EntryCount(); i++) {
		const gpt_partition_entry& entry = header->EntryAt(i);

		if (entry.partition_type == kEmptyGUID)
			continue;

		if (entry.EndBlock() * partition->block_size
				> (uint64)partition->size) {
			TRACE(("efi_gpt: child partition exceeds existing space (ends at "
				"block %" B_PRIu64 ")\n", entry.EndBlock()));
			continue;
		}

		if (entry.StartBlock() * partition->block_size == 0) {
			TRACE(("efi_gpt: child partition starts at 0 (recursive entry)\n"));
			continue;
		}

		partition_data* child = create_child_partition(partition->id, index++,
			partition->offset + entry.StartBlock() * partition->block_size,
			entry.BlockCount() * partition->block_size, -1);
		if (child == NULL) {
			TRACE(("efi_gpt: Creating child at index %" B_PRIu32 " failed\n",
				index - 1));
			return B_ERROR;
		}

		char name[B_OS_NAME_LENGTH];
		to_utf8(entry.name, EFI_PARTITION_NAME_LENGTH, name, sizeof(name));
		child->name = strdup(name);
		child->type = strdup(get_partition_type(entry.partition_type));
		child->block_size = partition->block_size;
		child->cookie = (void*)(addr_t)i;
		child->content_cookie = header;
	}

	return B_OK;
}


static void
efi_gpt_free_identify_partition_cookie(partition_data* partition, void* _cookie)
{
	// Cookie is freed in efi_gpt_free_partition_content_cookie().
}


static void
efi_gpt_free_partition_content_cookie(partition_data* partition)
{
	delete (EFI::Header*)partition->content_cookie;
}


#ifndef _BOOT_MODE
static uint32
efi_gpt_get_supported_operations(partition_data* partition, uint32 mask)
{
	uint32 flags = B_DISK_SYSTEM_SUPPORTS_INITIALIZING
		| B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_NAME
		| B_DISK_SYSTEM_SUPPORTS_MOVING
		| B_DISK_SYSTEM_SUPPORTS_RESIZING
		| B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD;
		// TODO: check for available entries and partitionable space and only
		// add creating child support if both is valid

	return flags;
}


static uint32
efi_gpt_get_supported_child_operations(partition_data* partition,
	partition_data* child, uint32 mask)
{
	return B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD
		| B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD
		| B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE
		| B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD;
}


static bool
efi_gpt_is_sub_system_for(partition_data* partition)
{
	// a GUID Partition Table doesn't usually live inside another partition
	return false;
}


static bool
efi_gpt_validate_resize(partition_data* partition, off_t* size)
{
	off_t newSize = *size;
	if (newSize == partition->size)
		return true;

	if (newSize < 0)
		newSize = 0;
	else
		newSize = block_align(partition, newSize, false);

	// growing
	if (newSize > partition->size) {
		*size = newSize;
		return true;
	}

	// shrinking, only so that no child would be truncated
	off_t newEnd = partition->offset + newSize;
	for (int32 i = 0; i < partition->child_count; i++) {
		partition_data* child = get_child_partition(partition->id, i);
		if (child == NULL)
			continue;

		if (child->offset + child->size > newEnd)
			newEnd = child->offset + child->size;
	}

	newSize = block_align(partition, newEnd - partition->offset, true);
	*size = newSize;
	return true;
}


static bool
efi_gpt_validate_resize_child(partition_data* partition, partition_data* child,
	off_t* size)
{
	off_t newSize = *size;
	if (newSize == child->size)
		return true;

	// shrinking
	if (newSize < child->size) {
		if (newSize < 0)
			newSize = 0;

		*size = block_align(partition, newSize, false);
		return true;
	}

	// growing, but only so much that the child doesn't get bigger than
	// the parent
	if (child->offset + newSize > partition->offset + partition->size)
		newSize = partition->offset + partition->size - child->offset;

	// make sure that the child doesn't overlap any sibling partitions
	off_t newEnd = child->offset + newSize;
	for (int32 i = 0; i < partition->child_count; i++) {
		partition_data* other = get_child_partition(partition->id, i);
		if (other == NULL || other->id == child->id
			|| other->offset < child->offset)
			continue;

		if (newEnd > other->offset)
			newEnd = other->offset;
	}

	*size = block_align(partition, newEnd - child->offset, false);
	return true;
}


static bool
efi_gpt_validate_move(partition_data* partition, off_t* start)
{
	// nothing to do
	return true;
}


static bool
efi_gpt_validate_move_child(partition_data* partition, partition_data* child,
	off_t* start)
{
	off_t newStart = *start;
	if (newStart < 0)
		newStart = 0;

	if (newStart + child->size > partition->size)
		newStart = partition->size - child->size;

	newStart = block_align(partition, newStart, false);
	if (newStart > child->offset) {
		for (int32 i = 0; i < partition->child_count; i++) {
			partition_data* other = get_child_partition(partition->id, i);
			if (other == NULL || other->id == child->id
				|| other->offset < child->offset)
				continue;

			if (other->offset < newStart + child->size)
				newStart = other->offset - child->size;
		}

		newStart = block_align(partition, newStart, false);
	} else {
		for (int32 i = 0; i < partition->child_count; i++) {
			partition_data* other = get_child_partition(partition->id, i);
			if (other == NULL || other->id == child->id
				|| other->offset > child->offset)
				continue;

			if (other->offset + other->size > newStart)
				newStart = other->offset + other->size;
		}

		newStart = block_align(partition, newStart, true);
	}

	*start = newStart;
	return true;
}


static bool
efi_gpt_validate_set_name(partition_data* partition, char* name)
{
	// TODO: should validate that the utf-8 -> ucs-2 is valid
	// TODO: should count actual utf-8 chars
	if (strlen(name) > EFI_PARTITION_NAME_LENGTH)
		name[EFI_PARTITION_NAME_LENGTH - 1] = 0;
	return true;
}


static bool
efi_gpt_validate_set_type(partition_data* partition, const char* type)
{
	guid_t typeGUID;
	return get_guid_for_partition_type(type, typeGUID);
}


static bool
efi_gpt_validate_initialize(partition_data* partition, char* name,
	const char* parameters)
{
	if ((efi_gpt_get_supported_operations(partition, ~0)
		& B_DISK_SYSTEM_SUPPORTS_INITIALIZING) == 0)
		return false;

	// name and parameters are ignored
	if (name != NULL)
		name[0] = 0;

	return true;
}


static bool
efi_gpt_validate_create_child(partition_data* partition, off_t* start,
	off_t* size, const char* type, const char* name, const char* parameters,
	int32* index)
{
	if ((efi_gpt_get_supported_operations(partition, ~0)
			& B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD) == 0)
		return false;

	if (!efi_gpt_validate_set_type(partition, type))
		return false;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	int32 entryIndex = -1;
	for (uint32 i = 0; i < header->EntryCount(); i++) {
		const gpt_partition_entry& entry = header->EntryAt(i);
		if (entry.partition_type == kEmptyGUID) {
			entryIndex = i;
			break;
		}
	}

	if (entryIndex < 0)
		return false;

	*index = entryIndex;

	// ensure that child lies between first and last usable block
	off_t firstUsable = header->FirstUsableBlock() * partition->block_size;
	if (*start < firstUsable)
		*start = firstUsable;

	off_t lastUsable = header->LastUsableBlock() * partition->block_size;
	if (*start + *size > lastUsable) {
		if (*start > lastUsable)
			return false;

		*size = lastUsable - *start;
	}

	// ensure that we don't overlap any siblings
	for (int32 i = 0; i < partition->child_count; i++) {
		partition_data* other = get_child_partition(partition->id, i);
		if (other == NULL)
			continue;

		if (other->offset < *start && other->offset + other->size > *start)
			*start = other->offset + other->size;

		if (other->offset > *start && other->offset < *start + *size)
			*size = other->offset - *start;
	}

	*start = block_align(partition, *start, true);
	*size = block_align(partition, *size, false);

	// TODO: support parameters
	return true;
}


static status_t
efi_gpt_get_partitionable_spaces(partition_data* partition,
	partitionable_space_data* buffer, int32 count, int32* actualCount)
{
	// TODO: implement
	return B_ERROR;
}


static status_t
efi_gpt_get_next_supported_type(partition_data* partition, int32* cookie,
	char* type)
{
	// TODO: implement
	return B_ERROR;
}


static status_t
efi_gpt_shadow_changed(partition_data* partition, partition_data* child,
	uint32 operation)
{
	// TODO: implement
	return B_ERROR;
}


static status_t
efi_gpt_repair(int fd, partition_id partition, bool checkOnly, disk_job_id job)
{
	// TODO: implement, validate CRCs and restore from backup area if corrupt
	return B_ERROR;
}


static status_t
efi_gpt_resize(int fd, partition_id partitionID, off_t size, disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	off_t validatedSize = size;
	if (!efi_gpt_validate_resize(partition, &validatedSize))
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	partition->size = validatedSize;
	partition->content_size = validatedSize;

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_resize_child(int fd, partition_id partitionID, off_t size,
	disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* child = get_partition(partitionID);
	if (child == NULL)
		return B_BAD_VALUE;

	partition_data* partition = get_parent_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	uint32 entryIndex = (uint32)(addr_t)child->cookie;
	if (entryIndex >= header->EntryCount())
		return B_BAD_VALUE;

	off_t validatedSize = size;
	if (!efi_gpt_validate_resize_child(partition, child, &validatedSize))
		return B_BAD_VALUE;

	if (child->size == validatedSize)
		return B_OK;

	update_disk_device_job_progress(job, 0.0);

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	entry.SetBlockCount(validatedSize / partition->block_size);

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK) {
		entry.SetBlockCount(child->size / partition->block_size);
		return result;
	}

	child->size = validatedSize;

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_move(int fd, partition_id partition, off_t offset, disk_job_id job)
{
	// nothing to do here
	return B_OK;
}


static status_t
efi_gpt_move_child(int fd, partition_id partitionID, partition_id childID,
	off_t offset, disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	partition_data* child = get_partition(childID);
	if (child == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	uint32 entryIndex = (uint32)(addr_t)child->cookie;
	if (entryIndex >= header->EntryCount())
		return B_BAD_VALUE;

	off_t validatedOffset = offset;
	if (!efi_gpt_validate_move_child(partition, child, &validatedOffset))
		return B_BAD_VALUE;

	if (child->offset == validatedOffset)
		return B_OK;

	// TODO: implement actual moving, need to move the partition content
	// (the raw data) here and need to take overlap into account
	return B_ERROR;

	update_disk_device_job_progress(job, 0.0);

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	uint64 blockCount = entry.BlockCount();
	entry.SetStartBlock((validatedOffset - partition->offset)
		/ partition->block_size);
	entry.SetBlockCount(blockCount);

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK) {
		// fatal error: the data has been moved but the partition table could
		// not be updated to reflect that change!
		return result;
	}

	child->offset = validatedOffset;

	update_disk_device_job_progress(job, 1.0);
	partition_modified(childID);
	return B_OK;
}


static status_t
efi_gpt_set_name(int fd, partition_id partitionID, const char* name,
	disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* child = get_partition(partitionID);
	if (child == NULL)
		return B_BAD_VALUE;

	partition_data* partition = get_parent_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	uint32 entryIndex = (uint32)(addr_t)child->cookie;
	if (entryIndex >= header->EntryCount())
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	to_ucs2(name, strlen(name), entry.name, EFI_PARTITION_NAME_LENGTH);

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK)
		return result;

	char newName[B_OS_NAME_LENGTH];
	to_utf8(entry.name, EFI_PARTITION_NAME_LENGTH, newName, sizeof(newName));
	child->name = strdup(newName);

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_set_type(int fd, partition_id partitionID, const char* type,
	disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* child = get_partition(partitionID);
	if (child == NULL)
		return B_BAD_VALUE;

	partition_data* partition = get_parent_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	uint32 entryIndex = (uint32)(addr_t)child->cookie;
	if (entryIndex >= header->EntryCount())
		return B_BAD_VALUE;

	guid_t typeGUID;
	if (!get_guid_for_partition_type(type, typeGUID))
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	entry.partition_type = typeGUID;

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK)
		return result;

	child->type = strdup(type);

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_initialize(int fd, partition_id partitionID, const char* name,
	const char* parameters, off_t partitionSize, disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	EFI::Header header((partitionSize - 1) / partition->block_size,
		partition->block_size);
	status_t result = header.InitCheck();
	if (result != B_OK)
		return result;

	result = header.Write(fd);
	if (result != B_OK)
		return result;

	result = scan_partition(partitionID);
	if (result != B_OK)
		return result;

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_uninitialize(int fd, partition_id partitionID, off_t partitionSize,
	uint32 blockSize, disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	const int headerSize = partition->block_size * 3;
	// The first block is the protective MBR
	// The second block is the GPT header
	// The third block is the start of the partition list (it can span more
	// blocks, but that doesn't matter as soon as the header is erased).

	uint8 buffer[headerSize];
	memset(buffer, 0xE5, sizeof(buffer));

	// Erase the first blocks
	if (write_pos(fd, 0, &buffer, headerSize) < 0)
		return errno;

	// Erase the last blocks
	// Only 2 blocks, as there is no protective MBR
	if (write_pos(fd, partitionSize - 2 * partition->block_size,
			&buffer, 2 * partition->block_size) < 0) {
		return errno;
	}

	update_disk_device_job_progress(job, 1.0);

	return B_OK;
}


static status_t
efi_gpt_create_child(int fd, partition_id partitionID, off_t offset,
	off_t size, const char* type, const char* name, const char* parameters,
	disk_job_id job, partition_id* childID)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	off_t validatedOffset = offset;
	off_t validatedSize = size;
	uint32 entryIndex = 0;

	if (!efi_gpt_validate_create_child(partition, &validatedOffset,
			&validatedSize, type, name, parameters, (int32*)&entryIndex))
		return B_BAD_VALUE;

	guid_t typeGUID;
	if (!get_guid_for_partition_type(type, typeGUID))
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	partition_data* child = create_child_partition(partition->id, entryIndex,
		validatedOffset, validatedSize, *childID);
	if (child == NULL)
		return B_ERROR;

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	entry.partition_type = typeGUID;
	uuid_t uuid;
	uuid_generate_random(uuid);
	memcpy((uint8*)&entry.unique_guid, uuid, sizeof(guid_t));
	to_ucs2(name, strlen(name), entry.name, EFI_PARTITION_NAME_LENGTH);
	entry.SetStartBlock((validatedOffset - partition->offset)
		/ partition->block_size);
	entry.SetBlockCount(validatedSize / partition->block_size);
	entry.SetAttributes(0); // TODO

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK) {
		delete_partition(child->id);
		return result;
	}

	*childID = child->id;
	child->block_size = partition->block_size;
	child->name = strdup(name);
	child->type = strdup(type);
	child->parameters = strdup(parameters);
	child->cookie = (void*)(addr_t)entryIndex;

	if (child->type == NULL || child->parameters == NULL) {
		delete_partition(child->id);
		return B_NO_MEMORY;
	}

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}


static status_t
efi_gpt_delete_child(int fd, partition_id partitionID, partition_id childID,
	disk_job_id job)
{
	if (fd < 0)
		return B_ERROR;

	PartitionWriteLocker locker(partitionID);
	if (!locker.IsLocked())
		return B_ERROR;

	partition_data* partition = get_partition(partitionID);
	if (partition == NULL)
		return B_BAD_VALUE;

	partition_data* child = get_partition(childID);
	if (child == NULL)
		return B_BAD_VALUE;

	EFI::Header* header = (EFI::Header*)partition->content_cookie;
	if (header == NULL)
		return B_BAD_VALUE;

	uint32 entryIndex = (uint32)(addr_t)child->cookie;
	if (entryIndex >= header->EntryCount())
		return B_BAD_VALUE;

	update_disk_device_job_progress(job, 0.0);

	if (!delete_partition(childID))
		return B_ERROR;

	gpt_partition_entry& entry = header->EntryAt(entryIndex);
	memset(&entry, 0, sizeof(gpt_partition_entry));
	entry.partition_type = kEmptyGUID;

	status_t result = header->WriteEntry(fd, entryIndex);
	if (result != B_OK)
		return result;

	update_disk_device_job_progress(job, 1.0);
	partition_modified(partitionID);
	return B_OK;
}
#endif // !_BOOT_MODE


#ifndef _BOOT_MODE
static partition_module_info sEFIPartitionModule = {
#else
partition_module_info gEFIPartitionModule = {
#endif
	{
		EFI_PARTITION_MODULE_NAME,
		0,
		efi_gpt_std_ops
	},
	"gpt",									// short_name
	EFI_PARTITION_NAME,						// pretty_name
	0										// flags
	| B_DISK_SYSTEM_SUPPORTS_INITIALIZING
	| B_DISK_SYSTEM_SUPPORTS_MOVING
	| B_DISK_SYSTEM_SUPPORTS_RESIZING
	| B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE
	| B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD
	| B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD
	| B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD
	| B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD
	| B_DISK_SYSTEM_SUPPORTS_SETTING_NAME
	| B_DISK_SYSTEM_SUPPORTS_NAME
	,

	// scanning
	efi_gpt_identify_partition,
	efi_gpt_scan_partition,
	efi_gpt_free_identify_partition_cookie,
	NULL, // free_partition_cookie
	efi_gpt_free_partition_content_cookie,

#ifndef _BOOT_MODE
	// querying
	efi_gpt_get_supported_operations,
	efi_gpt_get_supported_child_operations,
	NULL, // supports_initializing_child
	efi_gpt_is_sub_system_for,

	efi_gpt_validate_resize,
	efi_gpt_validate_resize_child,
	efi_gpt_validate_move,
	efi_gpt_validate_move_child,
	efi_gpt_validate_set_name,
	NULL, // validate_set_content_name
	efi_gpt_validate_set_type,
	NULL, // validate_set_parameters
	NULL, // validate_set_content_parameters
	efi_gpt_validate_initialize,
	efi_gpt_validate_create_child,
	efi_gpt_get_partitionable_spaces,
	efi_gpt_get_next_supported_type,
	NULL, // get_type_for_content_type

	// shadow partition modification
	efi_gpt_shadow_changed,

	// writing
	efi_gpt_repair,
	efi_gpt_resize,
	efi_gpt_resize_child,
	efi_gpt_move,
	efi_gpt_move_child,
	efi_gpt_set_name,
	NULL, // set_content_name
	efi_gpt_set_type,
	NULL, // set_parameters
	NULL, // set_content_parameters
	efi_gpt_initialize,
	efi_gpt_uninitialize,
	efi_gpt_create_child,
	efi_gpt_delete_child
#else
	NULL
#endif // _BOOT_MODE
};

#ifndef _BOOT_MODE
partition_module_info* modules[] = {
	&sEFIPartitionModule,
	NULL
};
#endif