status_t
_user_set_partition_content_parameters(partition_id partitionID,
int32* _changeCounter, const char* _parameters)
{
// copy parameters in
UserStringParameter<true> parameters;
int32 changeCounter;
status_t error
= parameters.Init(_parameters, B_DISK_DEVICE_MAX_PARAMETER_SIZE);
if (error != B_OK || (error = copy_from_user_value(changeCounter,
_changeCounter)) != B_OK) {
return error;
}
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (!partition)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
// the partition must be initialized
KDiskSystem* diskSystem = partition->DiskSystem();
if (!diskSystem)
return B_BAD_VALUE;
// mark the partition busy and unlock
if (!partition->CheckAndMarkBusy(true))
return B_BUSY;
locker.Unlock();
// set content parameters
error = diskSystem->SetContentParameters(partition, parameters.value,
DUMMY_JOB_ID);
// re-lock and unmark busy
locker.Lock();
partition->UnmarkBusy(true);
if (error != B_OK)
return error;
// return change counter
if ((error = copy_to_user_value(_changeCounter, partition->ChangeCounter()))
!= B_OK) {
return error;
}
return B_OK;
}
status_t
_user_repair_partition(partition_id partitionID, int32* _changeCounter,
bool checkOnly)
{
// copy parameters in
int32 changeCounter;
status_t error;
if ((error = copy_from_user_value(changeCounter, _changeCounter)) != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (!partition)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
// the partition must be initialized
KDiskSystem* diskSystem = partition->DiskSystem();
if (!diskSystem)
return B_BAD_VALUE;
// mark the partition busy and unlock
if (!partition->CheckAndMarkBusy(false))
return B_BUSY;
locker.Unlock();
// repair/check
error = diskSystem->Repair(partition, checkOnly, DUMMY_JOB_ID);
// re-lock and unmark busy
locker.Lock();
partition->UnmarkBusy(false);
if (error != B_OK)
return error;
// return change counter
if ((error = copy_to_user_value(_changeCounter, partition->ChangeCounter()))
!= B_OK) {
return error;
}
return B_OK;
}
status_t
_user_set_partition_content_name(partition_id partitionID,
int32* _changeCounter, const char* _name)
{
// copy parameters in
UserStringParameter<true> name;
int32 changeCounter;
status_t error = name.Init(_name, B_DISK_DEVICE_NAME_LENGTH);
if (error == B_OK)
error = copy_from_user_value(changeCounter, _changeCounter);
if (error != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (partition == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
// the partition must be initialized
KDiskSystem* diskSystem = partition->DiskSystem();
if (diskSystem == NULL)
return B_BAD_VALUE;
// mark the partition busy and unlock
if (!partition->CheckAndMarkBusy(false))
return B_BUSY;
locker.Unlock();
// set content parameters
error = diskSystem->SetContentName(partition, name.value, DUMMY_JOB_ID);
// re-lock and unmark busy
locker.Lock();
partition->UnmarkBusy(false);
if (error != B_OK)
return error;
// return change counter
return copy_to_user_value(_changeCounter, partition->ChangeCounter());
}
status_t
_user_delete_child_partition(partition_id partitionID, int32* _changeCounter,
partition_id childID, int32 childChangeCounter)
{
// copy parameters in
int32 changeCounter;
status_t error;
if ((error = copy_from_user_value(changeCounter, _changeCounter)) != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (partition == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// register child
KPartition* child = manager->RegisterPartition(childID);
if (child == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar3(child, true);
// check change counters
if (changeCounter != partition->ChangeCounter()
|| childChangeCounter != child->ChangeCounter()) {
return B_BAD_VALUE;
}
// the partition must be initialized
KDiskSystem* diskSystem = partition->DiskSystem();
if (diskSystem == NULL)
return B_BAD_VALUE;
// child must indeed be a child of partition
if (child->Parent() != partition)
return B_BAD_VALUE;
// mark the partition and child busy and unlock
if (partition->IsBusy() || !child->CheckAndMarkBusy(true))
return B_BUSY;
partition->SetBusy(true);
locker.Unlock();
// delete the child
error = diskSystem->DeleteChild(child, DUMMY_JOB_ID);
// re-lock and unmark busy
locker.Lock();
partition->SetBusy(false);
child->UnmarkBusy(true);
if (error != B_OK)
return error;
// return change counter
return copy_to_user_value(_changeCounter, partition->ChangeCounter());
}
status_t
_user_create_child_partition(partition_id partitionID, int32* _changeCounter,
off_t offset, off_t size, const char* _type, const char* _name,
const char* _parameters, partition_id* childID, int32* childChangeCounter)
{
// copy parameters in
UserStringParameter<false> type;
UserStringParameter<true> name;
UserStringParameter<true> parameters;
int32 changeCounter;
status_t error = type.Init(_type, B_DISK_DEVICE_TYPE_LENGTH);
if (error == B_OK)
error = name.Init(_name, B_DISK_DEVICE_NAME_LENGTH);
if (error == B_OK)
error = parameters.Init(_parameters, B_DISK_DEVICE_MAX_PARAMETER_SIZE);
if (error == B_OK)
error = copy_from_user_value(changeCounter, _changeCounter);
if (error != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (partition == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
// the partition must be initialized
KDiskSystem* diskSystem = partition->DiskSystem();
if (diskSystem == NULL)
return B_BAD_VALUE;
// mark the partition busy and unlock
if (!partition->CheckAndMarkBusy(false))
return B_BUSY;
locker.Unlock();
// create the child
KPartition *child = NULL;
error = diskSystem->CreateChild(partition, offset, size, type.value,
name.value, parameters.value, DUMMY_JOB_ID, &child, -1);
// re-lock and unmark busy
locker.Lock();
partition->UnmarkBusy(false);
if (error != B_OK)
return error;
if (child == NULL)
return B_ERROR;
child->UnmarkBusy(true);
// return change counter and child ID
error = copy_to_user_value(_changeCounter, partition->ChangeCounter());
if (error == B_OK)
error = copy_to_user_value(childID, child->ID());
return error;
}
status_t
_user_uninitialize_partition(partition_id partitionID, int32* _changeCounter,
partition_id parentID, int32* _parentChangeCounter)
{
// copy parameters in
int32 changeCounter;
int32 parentChangeCounter;
bool haveParent = parentID >= 0;
status_t error = copy_from_user_value(changeCounter, _changeCounter);
if (haveParent && error == B_OK)
error = copy_from_user_value(parentChangeCounter, _parentChangeCounter);
if (error != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (partition == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// register parent
KPartition* parent = NULL;
if (haveParent)
parent = manager->RegisterPartition(parentID);
PartitionRegistrar registrar3(parent, true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
if (haveParent && parentChangeCounter != parent->ChangeCounter())
return B_BAD_VALUE;
// the partition must be initialized
if (partition->DiskSystem() == NULL)
return B_BAD_VALUE;
// check busy
if (!partition->CheckAndMarkBusy(true))
return B_BUSY;
if (partition->IsMounted() || partition->IsChildMounted())
return B_BAD_VALUE;
KDiskSystem* diskSystem = partition->DiskSystem();
locker.Unlock();
// Let the disk system uninitialize the partition. This operation is not
// mandatory. If implemented, it will destroy the on-disk structures, so
// that the disk system cannot accidentally identify the partition later on.
if (diskSystem != NULL)
diskSystem->Uninitialize(partition, DUMMY_JOB_ID);
// re-lock and uninitialize the partition object
locker.Lock();
error = partition->UninitializeContents(true);
partition->UnmarkBusy(true);
if (error != B_OK)
return error;
// return change counter
error = copy_to_user_value(_changeCounter, partition->ChangeCounter());
if (haveParent && error == B_OK)
error = copy_to_user_value(_parentChangeCounter, parent->ChangeCounter());
return error;
}
status_t
_user_initialize_partition(partition_id partitionID, int32* _changeCounter,
const char* _diskSystemName, const char* _name, const char* _parameters)
{
// copy parameters in
UserStringParameter<false> diskSystemName;
UserStringParameter<true> name;
UserStringParameter<true> parameters;
int32 changeCounter;
status_t error
= diskSystemName.Init(_diskSystemName, B_DISK_SYSTEM_NAME_LENGTH);
if (error == B_OK)
error = name.Init(_name, B_DISK_DEVICE_NAME_LENGTH);
if (error == B_OK)
error = parameters.Init(_parameters, B_DISK_DEVICE_MAX_PARAMETER_SIZE);
if (error == B_OK)
error = copy_from_user_value(changeCounter, _changeCounter);
if (error != B_OK)
return error;
// get the partition
KDiskDeviceManager* manager = KDiskDeviceManager::Default();
KPartition* partition = manager->WriteLockPartition(partitionID);
if (partition == NULL)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true);
// check change counter
if (changeCounter != partition->ChangeCounter())
return B_BAD_VALUE;
// the partition must be uninitialized
if (partition->DiskSystem() != NULL)
return B_BAD_VALUE;
// load the new disk system
KDiskSystem *diskSystem = manager->LoadDiskSystem(diskSystemName.value,
true);
if (diskSystem == NULL)
return B_ENTRY_NOT_FOUND;
DiskSystemLoader loader(diskSystem, true);
// mark the partition busy and unlock
if (!partition->CheckAndMarkBusy(true))
return B_BUSY;
locker.Unlock();
// let the disk system initialize the partition
error = diskSystem->Initialize(partition, name.value, parameters.value,
DUMMY_JOB_ID);
// re-lock and unmark busy
locker.Lock();
partition->UnmarkBusy(true);
if (error != B_OK)
return error;
// Set the disk system. Re-check whether a disk system is already set on the
// partition. Some disk systems just write the on-disk structures and let
// the DDM rescan the partition, in which case the disk system will already
// be set. In very unfortunate cases the on-disk structure of the previous
// disk system has not been destroyed and the previous disk system has a
// higher priority than the new one. The old disk system will thus prevail.
// Not setting the new disk system will at least prevent that the partition
// object gets into an inconsistent state.
if (partition->DiskSystem() == NULL)
partition->SetDiskSystem(diskSystem);
// return change counter
return copy_to_user_value(_changeCounter, partition->ChangeCounter());
}