haiku.git

/*
 * Copyright 2013, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2007, Ingo Weinhold, bonefish@users.sf.net.
 * Distributed under the terms of the MIT License.
 */


#include "GPTPartitionHandle.h"

#include <new>
#include <stdio.h>

#include <DiskDeviceTypes.h>
#include <MutablePartition.h>
#include <PartitioningInfo.h>
#include <PartitionParameterEditor.h>
#include <Path.h>
#include <SupportDefs.h>

#include <AutoDeleter.h>

#include "guid.h"
#include "gpt_known_guids.h"
#include "utility.h"


//#define TRACE_GPT_PARTITION_HANDLE
#undef TRACE
#ifdef TRACE_GPT_PARTITION_HANDLE
#	define TRACE(x...) printf(x)
#else
#	define TRACE(x...) do {} while (false)
#endif


GPTPartitionHandle::GPTPartitionHandle(BMutablePartition* partition)
	:
	BPartitionHandle(partition)
{
}


GPTPartitionHandle::~GPTPartitionHandle()
{
}


status_t
GPTPartitionHandle::Init()
{
	// TODO: how to get the path of a BMutablePartition?
	//BPath path;
	//status_t status = Partition()->GetPath(&path);
	//if (status != B_OK)
		//return status;

	//fd = open(path.Path(), O_RDONLY);
	//if (fd < 0)
		//return errno;

	//fHeader = new EFI::Header(fd, Partition()->BlockSize(),
		//Partition()->BlockSize());
	//status = fHeader->InitCheck();
	//if (status != B_OK)
		//return status;

	//close(fd);
	return B_OK;
}


uint32
GPTPartitionHandle::SupportedOperations(uint32 mask)
{
	uint32 flags = B_DISK_SYSTEM_SUPPORTS_RESIZING
		| B_DISK_SYSTEM_SUPPORTS_MOVING
		| B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_PARAMETERS
		| B_DISK_SYSTEM_SUPPORTS_NAME
		| B_DISK_SYSTEM_SUPPORTS_SETTING_NAME
		| B_DISK_SYSTEM_SUPPORTS_INITIALIZING;

	// creating child
	if ((mask & B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD) != 0) {
		BPartitioningInfo info;
		if (GetPartitioningInfo(&info) == B_OK
			&& info.CountPartitionableSpaces() > 1) {
			flags |= B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD;
		}
	}

	return flags;
}


uint32
GPTPartitionHandle::SupportedChildOperations(const BMutablePartition* child,
	uint32 mask)
{
	return B_DISK_SYSTEM_SUPPORTS_NAME
		| B_DISK_SYSTEM_SUPPORTS_SETTING_NAME
		| B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD
		| B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD
		| B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE
		| B_DISK_SYSTEM_SUPPORTS_SETTING_PARAMETERS
		| B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD;
}


status_t
GPTPartitionHandle::GetNextSupportedType(const BMutablePartition* child,
	int32* cookie, BString* type)
{
	int32 index = *cookie;
	TRACE("GPTPartitionHandle::GetNextSupportedType(child: %p, cookie: %" B_PRId32 ")\n",
		child, index);

	if (index >= int32(B_COUNT_OF(kTypeMap)))
		return B_ENTRY_NOT_FOUND;

	type->SetTo(kTypeMap[index].type);
	*cookie = index + 1;

	return B_OK;
}


status_t
GPTPartitionHandle::GetPartitioningInfo(BPartitioningInfo* info)
{
	// init to the full size (minus the GPT table header and entries)
	off_t size = Partition()->ContentSize();
	// TODO: use fHeader
	size_t headerSize = Partition()->BlockSize() + 16384;
	status_t status = info->SetTo(Partition()->BlockSize() + headerSize,
		size - Partition()->BlockSize() - 2 * headerSize);
	if (status != B_OK)
		return status;

	// Exclude the space of the existing partitions
	size_t count = Partition()->CountChildren();
	for (size_t index = 0; index < count; index++) {
		BMutablePartition* child = Partition()->ChildAt(index);
		status = info->ExcludeOccupiedSpace(child->Offset(), child->Size());
		if (status != B_OK)
			return status;
	}

	return B_OK;
}


status_t
GPTPartitionHandle::GetParameterEditor(B_PARAMETER_EDITOR_TYPE type,
	BPartitionParameterEditor** editor)
{
	*editor = NULL;
	if (type == B_CREATE_PARAMETER_EDITOR || type == B_PROPERTIES_PARAMETER_EDITOR) {
		try {
			*editor = new BPartitionParameterEditor();
		} catch (std::bad_alloc&) {
			return B_NO_MEMORY;
		}
		return B_OK;
	}
	return B_NOT_SUPPORTED;
}


status_t
GPTPartitionHandle::ValidateSetName(const BMutablePartition *child, BString* name)
{
	// UCS-2 can use up to 2 code points per character, and GPT allows
	// a maximum of 36 code units;
	size_t length = name->CountChars();
	if (length == 0)
		return B_OK;

	size_t size = length * 2;
	uint16 buffer[size + 1];

	do {
		size = to_ucs2(name->String(), length, buffer, length * 2);
		if (size <= 36)
			return B_OK;
		length--;
		name->TruncateChars(length, false);
	} while (size > 36 && length > 0);

	return B_OK;
}


status_t
GPTPartitionHandle::SetName(BMutablePartition* child, const char* name)
{
	return child->SetName(name);
}


status_t
GPTPartitionHandle::ValidateSetType(const BMutablePartition* child,
	const char* type)
{
	for (size_t i = 0; i < B_COUNT_OF(kTypeMap); i++) {
		if (strcmp(type, kTypeMap[i].type) == 0)
			return B_OK;
	}
	return B_BAD_VALUE;
}


status_t
GPTPartitionHandle::SetType(BMutablePartition* child, const char* type)
{
	return child->SetType(type);
}


status_t
GPTPartitionHandle::ValidateCreateChild(off_t* _offset, off_t* _size,
	const char* typeString, BString* name, const char* parameters)
{
	return B_OK;
}


status_t
GPTPartitionHandle::CreateChild(off_t offset, off_t size,
	const char* typeString, const char* name, const char* parameters,
	BMutablePartition** _child)
{
	// create the child
	BMutablePartition* partition = Partition();
	BMutablePartition* child;
	status_t status = partition->CreateChild(partition->CountChildren(),
		typeString, name, parameters, &child);
	if (status != B_OK)
		return status;

	// init the child
	child->SetOffset(offset);
	child->SetSize(size);
	child->SetBlockSize(partition->BlockSize());

	*_child = child;
	return B_OK;
}


status_t
GPTPartitionHandle::DeleteChild(BMutablePartition* child)
{
	BMutablePartition* parent = child->Parent();
	return parent->DeleteChild(child);
}