Renamed system/core to system/kernel.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@12360 a95241bf-73f2-0310-859d-f6bbb57e9c96
2005-04-13 13:22:10 +00:00
parent 5af32e7526
commit 2d690920ac
212 changed files with 0 additions and 0 deletions
@@ -0,0 +1,668 @@
+// KPartitioningSystem.cpp
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <ddm_modules.h>
+#include <KDiskDevice.h>
+#include <KDiskDeviceJob.h>
+#include <KDiskDeviceManager.h>
+#include <KDiskDeviceUtils.h>
+#include <KPartition.h>
+#include <KPartitioningSystem.h>
+
+// constructor
+KPartitioningSystem::KPartitioningSystem(const char *name)
+	: KDiskSystem(name),
+	  fModule(NULL)
+{
+}
+
+// destructor
+KPartitioningSystem::~KPartitioningSystem()
+{
+}
+
+// Init
+status_t
+KPartitioningSystem::Init()
+{
+	status_t error = KDiskSystem::Init();
+	if (error != B_OK)
+		return error;
+	error = Load();
+	if (error != B_OK)
+		return error;
+	error = SetPrettyName(fModule->pretty_name);
+	SetFlags(fModule->flags & ~(uint32)B_DISK_SYSTEM_IS_FILE_SYSTEM);
+	Unload();
+	return error;
+}
+
+// Identify
+float
+KPartitioningSystem::Identify(KPartition *partition, void **cookie)
+{
+	if (!partition || !cookie || !fModule || !fModule->identify_partition)
+		return -1;
+	int fd = -1;
+	if (partition->Open(O_RDONLY, &fd) != B_OK)
+		return -1;
+	float result = fModule->identify_partition(fd, partition->PartitionData(),
+											   cookie);
+	close(fd);
+	return result;
+}
+
+// Scan
+status_t
+KPartitioningSystem::Scan(KPartition *partition, void *cookie)
+{
+	if (!partition || !fModule || !fModule->scan_partition)
+		return B_ERROR;
+	int fd = -1;
+	status_t result = partition->Open(O_RDONLY, &fd);
+	if (result != B_OK)
+		return result;
+	result = fModule->scan_partition(fd, partition->PartitionData(), cookie);
+	close(fd);
+	return result;
+}
+
+// FreeIdentifyCookie
+void
+KPartitioningSystem::FreeIdentifyCookie(KPartition *partition, void *cookie)
+{
+	if (!partition || !fModule || !fModule->free_identify_partition_cookie)
+		return;
+	fModule->free_identify_partition_cookie(partition->PartitionData(),
+											cookie);
+}
+
+// FreeCookie
+void
+KPartitioningSystem::FreeCookie(KPartition *partition)
+{
+	if (!partition || !fModule || !fModule->free_partition_cookie
+		|| partition->ParentDiskSystem() != this) {
+		return;
+	}
+	fModule->free_partition_cookie(partition->PartitionData());
+	partition->SetCookie(NULL);
+}
+
+// FreeContentCookie
+void
+KPartitioningSystem::FreeContentCookie(KPartition *partition)
+{
+	if (!partition || !fModule || !fModule->free_partition_content_cookie
+		|| partition->DiskSystem() != this) {
+		return;
+	}
+	fModule->free_partition_content_cookie(partition->PartitionData());
+	partition->SetContentCookie(NULL);
+}
+
+// SupportsRepairing
+bool
+KPartitioningSystem::SupportsRepairing(KPartition *partition, bool checkOnly,
+									   bool *whileMounted)
+{
+	bool _whileMounted = false;
+	if (!whileMounted)
+		whileMounted = &_whileMounted;
+	if (!partition || partition->DiskSystem() != this || !fModule
+		|| !fModule->supports_repairing) {
+		return (*whileMounted = false);
+	}
+	bool result = fModule->supports_repairing(partition->PartitionData(),
+											  checkOnly);
+	*whileMounted = result;
+	return result;
+}
+
+// SupportsResizing
+bool
+KPartitioningSystem::SupportsResizing(KPartition *partition,
+									  bool *whileMounted)
+{
+	bool _whileMounted = false;
+	if (!whileMounted)
+		whileMounted = &_whileMounted;
+	if (!partition || partition->DiskSystem() != this || !fModule ||
+		!fModule->supports_resizing) {
+		return (*whileMounted = false);
+	}
+	bool result = fModule->supports_resizing(partition->PartitionData());
+	*whileMounted = result;
+	return result;
+}
+
+// SupportsResizingChild
+bool
+KPartitioningSystem::SupportsResizingChild(KPartition *child)
+{
+	return (child && child->Parent() && child->ParentDiskSystem() == this
+			&& fModule && fModule->supports_resizing_child
+			&& fModule->supports_resizing_child(
+						child->Parent()->PartitionData(),
+						child->PartitionData()));
+}
+
+// SupportsMoving
+bool
+KPartitioningSystem::SupportsMoving(KPartition *partition, bool *isNoOp)
+{
+	bool _isNoOp = false;
+	if (!isNoOp)
+		isNoOp = &_isNoOp;
+	if (!partition || partition->DiskSystem() != this || !fModule
+		|| !fModule->supports_moving) {
+		return (*isNoOp = false);
+	}
+	return fModule->supports_moving(partition->PartitionData(), isNoOp);
+}
+
+// SupportsMovingChild
+bool
+KPartitioningSystem::SupportsMovingChild(KPartition *child)
+{
+	return (child && child->Parent() && child->ParentDiskSystem() != this
+			&& fModule && fModule->supports_moving_child
+			&& fModule->supports_moving_child(child->Parent()->PartitionData(),
+											  child->PartitionData()));
+}
+
+// SupportsSettingName
+bool
+KPartitioningSystem::SupportsSettingName(KPartition *partition)
+{
+	return (partition && partition->ParentDiskSystem() == this
+			&& fModule && fModule->supports_setting_name
+			&& fModule->supports_setting_name(partition->PartitionData()));
+}
+
+// SupportsSettingContentName
+bool
+KPartitioningSystem::SupportsSettingContentName(KPartition *partition,
+												bool *whileMounted)
+{
+	bool _whileMounted = false;
+	if (!whileMounted)
+		whileMounted = &_whileMounted;
+	if (!partition || partition->DiskSystem() != this || !fModule
+		|| !fModule->supports_setting_content_name) {
+		return (*whileMounted = false);
+	}
+	bool result = fModule->supports_setting_content_name(
+		partition->PartitionData());
+	*whileMounted = result;
+	return result;
+}
+
+// SupportsSettingType
+bool
+KPartitioningSystem::SupportsSettingType(KPartition *partition)
+{
+	return (partition && partition->ParentDiskSystem() == this
+			&& fModule && fModule->supports_setting_type
+			&& fModule->supports_setting_type(partition->PartitionData()));
+}
+
+// SupportsSettingParameters
+bool
+KPartitioningSystem::SupportsSettingParameters(KPartition *partition)
+{
+	return (partition && partition->ParentDiskSystem() == this
+			&& fModule && fModule->supports_setting_parameters
+			&& fModule->supports_setting_parameters(
+					partition->PartitionData()));
+}
+
+// SupportsSettingContentParameters
+bool
+KPartitioningSystem::SupportsSettingContentParameters(KPartition *partition,
+													  bool *whileMounted)
+{
+	bool _whileMounted = false;
+	if (!whileMounted)
+		whileMounted = &_whileMounted;
+	if (!partition || partition->DiskSystem() != this || !fModule
+		|| !fModule->supports_setting_content_parameters) {
+		return (*whileMounted = false);
+	}
+	bool result = fModule->supports_setting_content_parameters(
+		partition->PartitionData());
+	*whileMounted = result;
+	return result;
+}
+
+// SupportsInitializing
+bool
+KPartitioningSystem::SupportsInitializing(KPartition *partition)
+{
+	return (partition && fModule && fModule->supports_initializing
+			&& fModule->supports_initializing(partition->PartitionData()));
+}
+
+// SupportsInitializingChild
+bool
+KPartitioningSystem::SupportsInitializingChild(KPartition *child,
+											   const char *diskSystem)
+{
+	return (child && child->ParentDiskSystem() == this && diskSystem
+			&& fModule && fModule->supports_initializing_child
+			&& fModule->supports_initializing_child(child->PartitionData(),
+													diskSystem));
+}
+
+// SupportsCreatingChild
+bool
+KPartitioningSystem::SupportsCreatingChild(KPartition *partition)
+{
+	return (partition && partition->DiskSystem() == this
+			&& fModule && fModule->supports_creating_child
+			&& fModule->supports_creating_child(partition->PartitionData()));
+}
+
+// SupportsDeletingChild
+bool
+KPartitioningSystem::SupportsDeletingChild(KPartition *child)
+{
+	return (child && child->Parent() && child->ParentDiskSystem() == this
+			&& fModule && fModule->supports_deleting_child
+			&& fModule->supports_deleting_child(
+					child->Parent()->PartitionData(), child->PartitionData()));
+}
+
+// IsSubSystemFor
+bool
+KPartitioningSystem::IsSubSystemFor(KPartition *partition)
+{
+	return (partition && fModule && fModule->is_sub_system_for
+			&& fModule->is_sub_system_for(partition->PartitionData()));
+}
+
+// ValidateResize
+bool
+KPartitioningSystem::ValidateResize(KPartition *partition, off_t *size)
+{
+	return (partition && size && partition->DiskSystem() == this && fModule
+			&& fModule->validate_resize
+			&& fModule->validate_resize(partition->PartitionData(), size));
+}
+
+// ValidateResizeChild
+bool
+KPartitioningSystem::ValidateResizeChild(KPartition *child, off_t *size)
+{
+	return (child && size && child->Parent()
+			&& child->ParentDiskSystem() == this && fModule
+			&& fModule->validate_resize_child
+			&& fModule->validate_resize_child(child->Parent()->PartitionData(),
+											  child->PartitionData(), size));
+}
+
+// ValidateMove
+bool
+KPartitioningSystem::ValidateMove(KPartition *partition, off_t *start)
+{
+	return (partition && start && partition->DiskSystem() == this && fModule
+			&& fModule->validate_move
+			&& fModule->validate_move(partition->PartitionData(), start));
+}
+
+// ValidateMoveChild
+bool
+KPartitioningSystem::ValidateMoveChild(KPartition *child, off_t *start)
+{
+	return (child && start && child->Parent()
+			&& child->ParentDiskSystem() == this && fModule
+			&& fModule->validate_move_child
+			&& fModule->validate_move_child(child->Parent()->PartitionData(),
+											child->PartitionData(), start));
+}
+
+// ValidateSetName
+bool
+KPartitioningSystem::ValidateSetName(KPartition *partition, char *name)
+{
+	return (partition && name && partition->Parent()
+			&& partition->ParentDiskSystem() == this && fModule
+			&& fModule->validate_set_name
+			&& fModule->validate_set_name(partition->PartitionData(), name));
+}
+
+// ValidateSetContentName
+bool
+KPartitioningSystem::ValidateSetContentName(KPartition *partition, char *name)
+{
+	return (partition && name && partition->DiskSystem() == this
+			&& fModule && fModule->validate_set_content_name
+			&& fModule->validate_set_content_name(partition->PartitionData(),
+												  name));
+}
+
+// ValidateSetType
+bool
+KPartitioningSystem::ValidateSetType(KPartition *partition, const char *type)
+{
+	return (partition && type && partition->ParentDiskSystem() == this
+			&& fModule && fModule->validate_set_type
+			&& fModule->validate_set_type(partition->PartitionData(), type));
+}
+
+// ValidateSetParameters
+bool
+KPartitioningSystem::ValidateSetParameters(KPartition *partition,
+										   const char *parameters)
+{
+	return (partition && partition->ParentDiskSystem() == this 
+			&& fModule && fModule->validate_set_parameters
+			&& fModule->validate_set_parameters(partition->PartitionData(),
+					parameters));
+}
+
+// ValidateSetContentParameters
+bool
+KPartitioningSystem::ValidateSetContentParameters(KPartition *partition,
+												  const char *parameters)
+{
+	return (partition && partition->DiskSystem() == this && fModule
+			&& fModule->validate_set_content_parameters
+			&& fModule->validate_set_content_parameters(
+					partition->PartitionData(), parameters));
+}
+
+// ValidateInitialize
+bool
+KPartitioningSystem::ValidateInitialize(KPartition *partition, char *name,
+										const char *parameters)
+{
+	return (partition && name && fModule && fModule->validate_initialize
+			&& fModule->validate_initialize(partition->PartitionData(), name,
+											parameters));
+}
+
+// ValidateCreateChild
+bool
+KPartitioningSystem::ValidateCreateChild(KPartition *partition, off_t *start,
+										 off_t *size, const char *type,
+										 const char *parameters, int32 *index)
+{
+	int32 _index = 0;
+	if (!index)
+		index = &_index;
+	return (partition && start && size && type
+			&& partition->DiskSystem() == this && fModule
+			&& fModule->validate_create_child
+			&& fModule->validate_create_child(partition->PartitionData(),
+											  start, size, type, parameters,
+											  index));
+}
+
+// CountPartitionableSpaces
+int32
+KPartitioningSystem::CountPartitionableSpaces(KPartition *partition)
+{
+	if (!partition || partition->DiskSystem() != this || !fModule)
+		return 0;
+	if (!fModule->get_partitionable_spaces) {
+		// TODO: Fallback algorithm.
+		return 0;
+	}
+	int32 count = 0;
+	status_t error = fModule->get_partitionable_spaces(
+		partition->PartitionData(), NULL, 0, &count);
+	return (error == B_OK || error == B_BUFFER_OVERFLOW ? count : 0);
+}
+
+// GetPartitionableSpaces
+status_t
+KPartitioningSystem::GetPartitionableSpaces(KPartition *partition,
+											partitionable_space_data *buffer,
+											int32 count, int32 *actualCount)
+{
+	if (!partition || partition->DiskSystem() != this || count > 0 && !buffer
+		|| !actualCount || !fModule) {
+		return B_BAD_VALUE;
+	}
+	if (!fModule->get_partitionable_spaces) {
+		// TODO: Fallback algorithm.
+		return B_ENTRY_NOT_FOUND;
+	}
+	return fModule->get_partitionable_spaces(partition->PartitionData(),
+											 buffer, count, actualCount);
+}
+
+// GetNextSupportedType
+status_t
+KPartitioningSystem::GetNextSupportedType(KPartition *partition, int32 *cookie,
+										  char *type)
+{
+	if (!partition || partition->DiskSystem() != this || !cookie || !type
+		|| !fModule) {
+		return B_BAD_VALUE;
+	}
+	if (!fModule->get_next_supported_type)
+		return B_ENTRY_NOT_FOUND;
+	return fModule->get_next_supported_type(partition->PartitionData(), cookie,
+											type);
+}
+
+// GetTypeForContentType
+status_t
+KPartitioningSystem::GetTypeForContentType(const char *contentType, char *type)
+{
+	if (!contentType || !type || !fModule)
+		return B_BAD_VALUE;
+	if (!fModule->get_type_for_content_type)
+		return B_ENTRY_NOT_FOUND;
+	return fModule->get_type_for_content_type(contentType, type);
+}
+
+// ShadowPartitionChanged
+status_t
+KPartitioningSystem::ShadowPartitionChanged(KPartition *partition,
+											uint32 operation)
+{
+	if (!partition)
+		return B_BAD_VALUE;
+	if (!fModule)
+		return B_ERROR;
+	// If not implemented, we assume, that the partitioning system doesn't
+	// have to make any additional changes.
+	if (!fModule->shadow_changed)
+		return B_OK;
+	return fModule->shadow_changed(partition->PartitionData(), operation);
+}
+
+// Repair
+status_t
+KPartitioningSystem::Repair(KPartition *partition, bool checkOnly,
+							KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// Resize
+status_t
+KPartitioningSystem::Resize(KPartition *partition, off_t size,
+							KDiskDeviceJob *job)
+{
+	// check parameters
+	if (!partition || !job || size < 0)
+		return B_BAD_VALUE;
+	if (!fModule->resize)
+		return B_ENTRY_NOT_FOUND;
+	// lock partition and open partition device
+	KDiskDeviceManager *manager = KDiskDeviceManager::Default();
+	KPartition *_partition = manager->ReadLockPartition(partition->ID());
+	if (!_partition)
+		return B_ERROR;
+	int fd = -1;
+	{
+		PartitionRegistrar registrar(_partition, true);
+		PartitionRegistrar deviceRegistrar(_partition->Device(), true);
+		DeviceReadLocker locker(_partition->Device(), true);
+		if (partition != _partition)
+			return B_ERROR;
+		status_t result = partition->Open(O_RDONLY, &fd);
+		if (result != B_OK)
+			return result;
+	}
+	// let the module do its job
+	status_t result = fModule->resize(fd, partition->ID(), size, job->ID());
+	// cleanup and return
+	close(fd);
+	return result;
+}
+
+// ResizeChild
+status_t
+KPartitioningSystem::ResizeChild(KPartition *child, off_t size,
+								 KDiskDeviceJob *job)
+{
+	// check parameters
+	if (!child || !job || size < 0)
+		return B_BAD_VALUE;
+	if (!fModule->resize_child)
+		return B_ENTRY_NOT_FOUND;
+	// lock partition and open (parent) partition device
+	KDiskDeviceManager *manager = KDiskDeviceManager::Default();
+	KPartition *_partition = manager->ReadLockPartition(child->ID());
+	if (!_partition)
+		return B_ERROR;
+	int fd = -1;
+	{
+		PartitionRegistrar registrar(_partition, true);
+		PartitionRegistrar deviceRegistrar(_partition->Device(), true);
+		DeviceReadLocker locker(_partition->Device(), true);
+		if (child != _partition)
+			return B_ERROR;
+		if (!child->Parent())
+			return B_BAD_VALUE;
+		status_t result = child->Parent()->Open(O_RDONLY, &fd);
+		if (result != B_OK)
+			return result;
+	}
+	// let the module do its job
+	status_t result = fModule->resize_child(fd, child->ID(), size, job->ID());
+	// cleanup and return
+	close(fd);
+	return result;
+}
+
+// Move
+status_t
+KPartitioningSystem::Move(KPartition *partition, off_t offset,
+						  KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// MoveChild
+status_t
+KPartitioningSystem::MoveChild(KPartition *child, off_t offset,
+							   KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// SetName
+status_t
+KPartitioningSystem::SetName(KPartition *partition, char *name,
+							 KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// SetContentName
+status_t
+KPartitioningSystem::SetContentName(KPartition *partition, char *name,
+									KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// SetType
+status_t
+KPartitioningSystem::SetType(KPartition *partition, char *type,
+							 KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// SetParameters
+status_t
+KPartitioningSystem::SetParameters(KPartition *partition,
+								   const char *parameters, KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// SetContentParameters
+status_t
+KPartitioningSystem::SetContentParameters(KPartition *partition,
+										  const char *parameters,
+										  KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// Initialize
+status_t
+KPartitioningSystem::Initialize(KPartition *partition, const char *name,
+								const char *parameters, KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// CreateChild
+status_t
+KPartitioningSystem::CreateChild(KPartition *partition, off_t offset,
+								 off_t size, const char *type,
+								 const char *parameters, KDiskDeviceJob *job,
+								 KPartition **child, partition_id childID)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// DeleteChild
+status_t
+KPartitioningSystem::DeleteChild(KPartition *child, KDiskDeviceJob *job)
+{
+	// to be implemented
+	return B_ERROR;
+}
+
+// LoadModule
+status_t
+KPartitioningSystem::LoadModule()
+{
+	if (fModule)		// shouldn't happen
+		return B_OK;
+	return get_module(Name(), (module_info**)&fModule);
+}
+
+// UnloadModule
+void
+KPartitioningSystem::UnloadModule()
+{
+	if (fModule) {
+		put_module(fModule->module.name);
+		fModule = NULL;
+	}
+}
+