haiku.git

/*
 * Copyright 2007, Ingo Weinhold, bonefish@users.sf.net.
 * Distributed under the terms of the MIT License.
 */


#include "PartitionMapAddOn.h"

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

#include <DiskDeviceTypes.h>
#include <MutablePartition.h>
#include <PartitioningInfo.h>

#include <AutoDeleter.h>

#include "IntelDiskSystem.h"
#include "PrimaryParameterEditor.h"


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


using std::nothrow;


// #pragma mark - PartitionMapAddOn


PartitionMapAddOn::PartitionMapAddOn()
	:
	BDiskSystemAddOn(kPartitionTypeIntel)
{
}


PartitionMapAddOn::~PartitionMapAddOn()
{
}


status_t
PartitionMapAddOn::CreatePartitionHandle(BMutablePartition* partition,
	BPartitionHandle** _handle)
{
	PartitionMapHandle* handle = new(nothrow) PartitionMapHandle(partition);
	if (!handle)
		return B_NO_MEMORY;

	status_t error = handle->Init();
	if (error != B_OK) {
		delete handle;
		return error;
	}

	*_handle = handle;
	return B_OK;
}


bool
PartitionMapAddOn::CanInitialize(const BMutablePartition* partition)
{
	// If it's big enough, but not too big (ie. larger than 2^32 blocks) we can
	// initialize it.
	return partition->Size() >= 2 * partition->BlockSize()
		&& partition->Size() / partition->BlockSize() < UINT32_MAX;
}


status_t
PartitionMapAddOn::ValidateInitialize(const BMutablePartition* partition,
	BString* name, const char* parameters)
{
	if (!CanInitialize(partition)
		|| (parameters != NULL && parameters[0] != '\0')) {
		return B_BAD_VALUE;
	}

	// we don't support a content name
	if (name != NULL)
		name->Truncate(0);

	return B_OK;
}


status_t
PartitionMapAddOn::Initialize(BMutablePartition* partition, const char* name,
	const char* parameters, BPartitionHandle** _handle)
{
	if (!CanInitialize(partition)
		|| (name != NULL && name[0] != '\0')
		|| (parameters != NULL && parameters[0] != '\0')) {
		return B_BAD_VALUE;
	}

	// create the handle
	PartitionMapHandle* handle = new(nothrow) PartitionMapHandle(partition);
	if (!handle)
		return B_NO_MEMORY;
	ObjectDeleter<PartitionMapHandle> handleDeleter(handle);

	// init the partition
	status_t error = partition->SetContentType(Name());
	if (error != B_OK)
		return error;
	// TODO: The content type could as well be set by the caller.

	partition->SetContentName(NULL);
	partition->SetContentParameters(NULL);
	partition->SetContentSize(
		sector_align(partition->Size(), partition->BlockSize()));
	partition->Changed(B_PARTITION_CHANGED_INITIALIZATION);

	*_handle = handleDeleter.Detach();

	return B_OK;
}


// #pragma mark - PartitionMapHandle


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


PartitionMapHandle::~PartitionMapHandle()
{
}


status_t
PartitionMapHandle::Init()
{
	// initialize the partition map from the mutable partition

	BMutablePartition* partition = Partition();

	int32 count = partition->CountChildren();
	if (count > 4)
		return B_BAD_VALUE;

	int32 extendedCount = 0;

	for (int32 i = 0; i < count; i++) {
		BMutablePartition* child = partition->ChildAt(i);
		PartitionType type;
		if (!type.SetType(child->Type()))
			return B_BAD_VALUE;

		// only one extended partition is allowed
		if (type.IsExtended()) {
			if (++extendedCount > 1)
				return B_BAD_VALUE;
		}

		// TODO: Get these from the parameters.
		int32 index = i;
		bool active = false;

		PrimaryPartition* primary = fPartitionMap.PrimaryPartitionAt(index);
		primary->SetTo(child->Offset(), child->Size(), type.Type(), active,
			partition->BlockSize());

		child->SetChildCookie(primary);
	}

	// The extended partition (if any) is initialized by
	// ExtendedPartitionHandle::Init().

	return B_OK;
}


uint32
PartitionMapHandle::SupportedOperations(uint32 mask)
{
	BMutablePartition* partition = Partition();

	uint32 flags = B_DISK_SYSTEM_SUPPORTS_RESIZING
		| B_DISK_SYSTEM_SUPPORTS_MOVING
		| B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_PARAMETERS
		| B_DISK_SYSTEM_SUPPORTS_INITIALIZING;

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

	return flags;
}


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


status_t
PartitionMapHandle::GetNextSupportedType(const BMutablePartition* child,
	int32* cookie, BString* type)
{
	TRACE("%p->PartitionMapHandle::GetNextSupportedType(child: %p, "
		"cookie: %ld)\n", this, child, *cookie);

	int32 index = *cookie;
	const partition_type* nextType;
	while (true) {
		nextType = fPartitionMap.GetNextSupportedPartitionType(index);
		if (nextType == NULL)
			return B_ENTRY_NOT_FOUND;
		index++;
		if (nextType->used)
			break;
}

	if (!nextType)
		return B_ENTRY_NOT_FOUND;

	type->SetTo(nextType->name);
	*cookie = index;

	return B_OK;
}


status_t
PartitionMapHandle::GetPartitioningInfo(BPartitioningInfo* info)
{
	// init to the full size (minus the first sector)
	off_t size = Partition()->ContentSize();
	status_t error = info->SetTo(Partition()->BlockSize(),
		size - Partition()->BlockSize());
	if (error != B_OK)
		return error;

	// exclude the space of the existing partitions
	for (int32 i = 0; i < 4; i++) {
		PrimaryPartition* primary = fPartitionMap.PrimaryPartitionAt(i);
		if (!primary->IsEmpty()) {
			error = info->ExcludeOccupiedSpace(primary->Offset(),
				primary->Size());
			if (error != B_OK)
				return error;
		}
	}

	return B_OK;
}


status_t
PartitionMapHandle::ValidateSetParameters(const BMutablePartition* child,
	const char* parameters)
{
	if (child == NULL || parameters == NULL)
		return B_NO_INIT;

	void* handle = parse_driver_settings_string(parameters);
	if (handle == NULL)
		return B_BAD_DATA;

	unload_driver_settings(handle);

	return B_OK;
}


status_t
PartitionMapHandle::SetParameters(BMutablePartition* child,
	const char* parameters)
{
	void* handle = parse_driver_settings_string(parameters);
	if (handle == NULL)
		return B_BAD_DATA;

	bool active = get_driver_boolean_parameter(handle, "active", false, true);
	unload_driver_settings(handle);

	// Update our local state
	PrimaryPartition* partition = (PrimaryPartition*)child->ChildCookie();
	partition->SetActive(active);

	// Forward the request to the BMutablePartition so it can be committed to
	// disk
	return child->SetParameters(parameters);
}


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


status_t
PartitionMapHandle::ValidateCreateChild(off_t* _offset, off_t* _size,
	const char* typeString, BString* name, const char* parameters)
{
	// check type
	PartitionType type;
	if (!type.SetType(typeString) || type.IsEmpty())
		return B_BAD_TYPE;

	if (type.IsExtended() && fPartitionMap.ExtendedPartitionIndex() >= 0) {
		// There can only be a single extended partition
		return B_NAME_IN_USE;
	}

	// check name
	if (name)
		name->Truncate(0);

	// check parameters
	void* handle = parse_driver_settings_string(parameters);
	if (handle == NULL)
		return B_ERROR;
	get_driver_boolean_parameter(handle, "active", false, true);
	unload_driver_settings(handle);

	// do we have a spare primary partition?
	if (fPartitionMap.CountNonEmptyPrimaryPartitions() == 4)
		return B_BAD_INDEX;

	// check the free space situation
	BPartitioningInfo info;
	status_t error = GetPartitioningInfo(&info);
	if (error != B_OK)
		return error;

	// any space in the partition at all?
	int32 spacesCount = info.CountPartitionableSpaces();
	if (spacesCount == 0)
		return B_DEVICE_FULL;

	// check offset and size
	off_t offset = sector_align(*_offset, Partition()->BlockSize());
	off_t size = sector_align(*_size, Partition()->BlockSize());
		// TODO: Rather round size up?
	off_t end = offset + size;

	// get the first partitionable space the requested interval intersects with
	int32 spaceIndex = -1;
	int32 closestSpaceIndex = -1;
	off_t closestSpaceDistance = 0;
	for (int32 i = 0; i < spacesCount; i++) {
		off_t spaceOffset, spaceSize;
		info.GetPartitionableSpaceAt(i, &spaceOffset, &spaceSize);
		off_t spaceEnd = spaceOffset + spaceSize;

		if ((spaceOffset >= offset && spaceOffset < end)
			|| (offset >= spaceOffset && offset < spaceEnd)) {
			spaceIndex = i;
			break;
		}

		off_t distance;
		if (offset < spaceOffset)
			distance = spaceOffset - end;
		else
			distance = spaceEnd - offset;

		if (closestSpaceIndex == -1 || distance < closestSpaceDistance) {
			closestSpaceIndex = i;
			closestSpaceDistance = distance;
		}
	}

	// get the space we found
	off_t spaceOffset, spaceSize;
	info.GetPartitionableSpaceAt(
		spaceIndex >= 0 ? spaceIndex : closestSpaceIndex, &spaceOffset,
		&spaceSize);
	off_t spaceEnd = spaceOffset + spaceSize;

	// If the requested intervald doesn't intersect with any space yet, move
	// it, so that it does.
	if (spaceIndex < 0) {
		spaceIndex = closestSpaceIndex;
		if (offset < spaceOffset) {
			offset = spaceOffset;
			end = offset + size;
		} else {
			end = spaceEnd;
			offset = end - size;
		}
	}

	// move/shrink the interval, so that it fully lies within the space
	if (offset < spaceOffset) {
		offset = spaceOffset;
		end = offset + size;
		if (end > spaceEnd) {
			end = spaceEnd;
			size = end - offset;
		}
	} else if (end > spaceEnd) {
		end = spaceEnd;
		offset = end - size;
		if (offset < spaceOffset) {
			offset = spaceOffset;
			size = end - offset;
		}
	}

	*_offset = offset;
	*_size = size;

	return B_OK;
}


status_t
PartitionMapHandle::CreateChild(off_t offset, off_t size,
	const char* typeString, const char* name, const char* parameters,
	BMutablePartition** _child)
{
	// check type
	PartitionType type;
	if (!type.SetType(typeString) || type.IsEmpty())
		return B_BAD_VALUE;
	if (type.IsExtended() && fPartitionMap.ExtendedPartitionIndex() >= 0)
		return B_BAD_VALUE;

	// check name
	if (name && *name != '\0')
		return B_BAD_VALUE;

	// check parameters
	void* handle = parse_driver_settings_string(parameters);
	if (handle == NULL)
		return B_ERROR;

	bool active = get_driver_boolean_parameter(handle, "active", false, true);
	unload_driver_settings(handle);

	// get a spare primary partition
	PrimaryPartition* primary = NULL;
	for (int32 i = 0; i < 4; i++) {
		if (fPartitionMap.PrimaryPartitionAt(i)->IsEmpty()) {
			primary = fPartitionMap.PrimaryPartitionAt(i);
			break;
		}
	}
	if (!primary)
		return B_BAD_VALUE;

	// offset properly aligned?
	if (offset != sector_align(offset, Partition()->BlockSize())
		|| size != sector_align(size, Partition()->BlockSize()))
		return B_BAD_VALUE;

	// check the free space situation
	BPartitioningInfo info;
	status_t error = GetPartitioningInfo(&info);
	if (error != B_OK)
		return error;

	bool foundSpace = false;
	off_t end = offset + size;
	int32 spacesCount = info.CountPartitionableSpaces();
	for (int32 i = 0; i < spacesCount; i++) {
		off_t spaceOffset, spaceSize;
		info.GetPartitionableSpaceAt(i, &spaceOffset, &spaceSize);
		off_t spaceEnd = spaceOffset + spaceSize;

		if (offset >= spaceOffset && end <= spaceEnd) {
			foundSpace = true;
			break;
		}
	}

	if (!foundSpace)
		return B_BAD_VALUE;

	// create the child
	// (Note: the primary partition index is indeed the child index, since
	// we picked the first empty primary partition.)
	BMutablePartition* partition = Partition();
	BMutablePartition* child;
	error = partition->CreateChild(primary->Index(), typeString, name,
		parameters, &child);
	if (error != B_OK)
		return error;

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

	// init the primary partition
	primary->SetTo(offset, size, type.Type(), active, partition->BlockSize());

	*_child = child;
	return B_OK;
}


status_t
PartitionMapHandle::DeleteChild(BMutablePartition* child)
{
	BMutablePartition* parent = child->Parent();
	status_t error = parent->DeleteChild(child);

	return error;
}