i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Fixed gcc 4 warnings.

Browse Source 
* Style cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22453 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
2007-10-05 22:39:52 +00:00
parent 7ca40195ba
commit d6e565c76b
1 changed files with 168 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/system/kernel/disk_device_manager/ddm_userland_interface.cpp
+168 -120
View File
@@ -1,4 +1,4 @@
/** \file ddm_userland_interface.cpp /** \file ddm_userland_interface.cpp
* *
* \brief Interface for userspace calls. * \brief Interface for userspace calls.
*/ */
@@ -34,18 +34,21 @@ using namespace BPrivate::DiskDevice;
\a from is longer than \to. If \c false, returns \c B_NAME_TOO_LONG \a from is longer than \to. If \c false, returns \c B_NAME_TOO_LONG
if \a from is longer than \to. if \a from is longer than \to.
*/ */
static static status_t
status_t ddm_strlcpy(char *to, const char *from, size_t size,
ddm_strlcpy(char *to, const char *from, size_t size, bool allowTruncation = false) { bool allowTruncation = false)
int error = user_strlcpy(to, from, size); {
error = (0 <= error && size_t(error) < size) ? B_OK ssize_t fromLen = user_strlcpy(to, from, size);
: (error < B_OK ? error : (allowTruncation ? B_OK : B_NAME_TOO_LONG)); if (fromLen < 0)
return status_t(error); return fromLen;
if ((size_t)fromLen >= size && !allowTruncation)
return B_NAME_TOO_LONG;
return B_OK;
} }
// move_descendants // move_descendants
static static void
void
move_descendants(KPartition *partition, off_t moveBy) move_descendants(KPartition *partition, off_t moveBy)
{ {
if (!partition) if (!partition)
@@ -56,9 +59,9 @@ move_descendants(KPartition *partition, off_t moveBy)
move_descendants(child, moveBy); move_descendants(child, moveBy);
} }
// move_descendants_contents // move_descendants_contents
static static status_t
status_t
move_descendants_contents(KPartition *partition) move_descendants_contents(KPartition *partition)
{ {
if (!partition) if (!partition)
@@ -80,6 +83,7 @@ move_descendants_contents(KPartition *partition)
return B_OK; return B_OK;
} }
// _user_get_next_disk_device_id // _user_get_next_disk_device_id
partition_id partition_id
_user_get_next_disk_device_id(int32 *_cookie, size_t *neededSize) _user_get_next_disk_device_id(int32 *_cookie, size_t *neededSize)
@@ -110,6 +114,7 @@ _user_get_next_disk_device_id(int32 *_cookie, size_t *neededSize)
return id; return id;
} }
// _user_find_disk_device // _user_find_disk_device
partition_id partition_id
_user_find_disk_device(const char *_filename, size_t *neededSize) _user_find_disk_device(const char *_filename, size_t *neededSize)
@@ -141,6 +146,7 @@ _user_find_disk_device(const char *_filename, size_t *neededSize)
return id; return id;
} }
// _user_find_partition // _user_find_partition
partition_id partition_id
_user_find_partition(const char *_filename, size_t *neededSize) _user_find_partition(const char *_filename, size_t *neededSize)
@@ -177,6 +183,7 @@ _user_find_partition(const char *_filename, size_t *neededSize)
return id; return id;
} }
// _user_get_disk_device_data // _user_get_disk_device_data
/*! \brief Writes data describing the disk device identified by ID and all /*! \brief Writes data describing the disk device identified by ID and all
its partitions into the supplied buffer. its partitions into the supplied buffer.
@@ -221,8 +228,7 @@ _user_find_partition(const char *_filename, size_t *neededSize)
*/ */
status_t status_t
_user_get_disk_device_data(partition_id id, bool deviceOnly, bool shadow, _user_get_disk_device_data(partition_id id, bool deviceOnly, bool shadow,
user_disk_device_data *buffer, size_t bufferSize, user_disk_device_data *buffer, size_t bufferSize, size_t *_neededSize)
size_t *_neededSize)
{ {
if (!buffer && bufferSize > 0) if (!buffer && bufferSize > 0)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -272,42 +278,45 @@ _user_get_disk_device_data(partition_id id, bool deviceOnly, bool shadow,
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_get_partitionable_spaces // _user_get_partitionable_spaces
status_t status_t
_user_get_partitionable_spaces(partition_id partitionID, int32 changeCounter, _user_get_partitionable_spaces(partition_id partitionID, int32 changeCounter,
partitionable_space_data *_buffer, partitionable_space_data *_buffer, int32 count, int32 *_actualCount)
int32 count, int32 *_actualCount)
{ {
if (!_buffer && count > 0) if (!_buffer && count > 0)
return B_BAD_VALUE; return B_BAD_VALUE;
// copy in // copy in
int32 bufferSize = count * sizeof(partitionable_space_data); int32 bufferSize = count * sizeof(partitionable_space_data);
partitionable_space_data *buffer = count > 0 partitionable_space_data *buffer = count > 0
? reinterpret_cast<partitionable_space_data*>(malloc(bufferSize)) ? reinterpret_cast<partitionable_space_data*>(malloc(bufferSize))
: NULL; : NULL;
if (buffer) if (buffer)
user_memcpy(buffer, _buffer, bufferSize); user_memcpy(buffer, _buffer, bufferSize);
status_t error = B_OK; status_t error = B_OK;
// get the partition // get the partition
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
KPartition *partition = manager->ReadLockPartition(partitionID); KPartition *partition = manager->ReadLockPartition(partitionID);
error = partition ? B_OK : B_ENTRY_NOT_FOUND; error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
error = check_shadow_partition(partition, changeCounter) ? B_OK : B_BAD_VALUE; error = check_shadow_partition(partition, changeCounter)
? B_OK : B_BAD_VALUE;
if (!error) { if (!error) {
// get the disk system // get the disk system
KDiskSystem *diskSystem = partition->DiskSystem(); KDiskSystem *diskSystem = partition->DiskSystem();
error = diskSystem ? B_OK : B_ENTRY_NOT_FOUND; error = diskSystem ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
// get the info // get the info
int32 actualCount; int32 actualCount;
error = diskSystem->GetPartitionableSpaces(partition, buffer, error = diskSystem->GetPartitionableSpaces(partition, buffer,
count, &actualCount); count, &actualCount);
if (!error && _actualCount) if (!error && _actualCount) {
user_memcpy(_actualCount, &actualCount, sizeof(actualCount)); user_memcpy(_actualCount, &actualCount,
sizeof(actualCount));
}
} }
} }
} }
@@ -318,6 +327,7 @@ _user_get_partitionable_spaces(partition_id partitionID, int32 changeCounter,
return error; return error;
} }
// _user_register_file_device // _user_register_file_device
partition_id partition_id
_user_register_file_device(const char *_filename) _user_register_file_device(const char *_filename)
@@ -337,6 +347,7 @@ _user_register_file_device(const char *_filename)
return B_ERROR; return B_ERROR;
} }
// _user_unregister_file_device // _user_unregister_file_device
status_t status_t
_user_unregister_file_device(partition_id deviceID, const char *_filename) _user_unregister_file_device(partition_id deviceID, const char *_filename)
@@ -355,6 +366,7 @@ _user_unregister_file_device(partition_id deviceID, const char *_filename)
} }
} }
// _user_get_disk_system_info // _user_get_disk_system_info
status_t status_t
_user_get_disk_system_info(disk_system_id id, user_disk_system_info *_info) _user_get_disk_system_info(disk_system_id id, user_disk_system_info *_info)
@@ -374,6 +386,7 @@ _user_get_disk_system_info(disk_system_id id, user_disk_system_info *_info)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_get_next_disk_system_info // _user_get_next_disk_system_info
status_t status_t
_user_get_next_disk_system_info(int32 *_cookie, user_disk_system_info *_info) _user_get_next_disk_system_info(int32 *_cookie, user_disk_system_info *_info)
@@ -397,6 +410,7 @@ _user_get_next_disk_system_info(int32 *_cookie, user_disk_system_info *_info)
return result; return result;
} }
// _user_find_disk_system // _user_find_disk_system
status_t status_t
_user_find_disk_system(const char *_name, user_disk_system_info *_info) _user_find_disk_system(const char *_name, user_disk_system_info *_info)
@@ -420,10 +434,11 @@ _user_find_disk_system(const char *_name, user_disk_system_info *_info)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_supports_defragmenting_partition // _user_supports_defragmenting_partition
bool bool
_user_supports_defragmenting_partition(partition_id partitionID, _user_supports_defragmenting_partition(partition_id partitionID,
int32 changeCounter, bool *_whileMounted) int32 changeCounter, bool *_whileMounted)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -435,17 +450,17 @@ _user_supports_defragmenting_partition(partition_id partitionID,
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
bool whileMounted; bool whileMounted;
bool result = validate_defragment_partition(partition, changeCounter, bool result = validate_defragment_partition(partition, changeCounter,
&whileMounted) == B_OK; &whileMounted) == B_OK;
if (result && _whileMounted) if (result && _whileMounted)
user_memcpy(_whileMounted, &whileMounted, sizeof(whileMounted)); user_memcpy(_whileMounted, &whileMounted, sizeof(whileMounted));
return result; return result;
} }
// _user_supports_repairing_partition // _user_supports_repairing_partition
bool bool
_user_supports_repairing_partition(partition_id partitionID, _user_supports_repairing_partition(partition_id partitionID,
int32 changeCounter, bool checkOnly, int32 changeCounter, bool checkOnly, bool *_whileMounted)
bool *_whileMounted)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -457,17 +472,17 @@ _user_supports_repairing_partition(partition_id partitionID,
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
bool whileMounted; bool whileMounted;
bool result = validate_repair_partition(partition, changeCounter, checkOnly, bool result = validate_repair_partition(partition, changeCounter, checkOnly,
&whileMounted) == B_OK; &whileMounted) == B_OK;
if (result && _whileMounted) if (result && _whileMounted)
user_memcpy(_whileMounted, &whileMounted, sizeof(whileMounted)); user_memcpy(_whileMounted, &whileMounted, sizeof(whileMounted));
return result; return result;
} }
// _user_supports_resizing_partition // _user_supports_resizing_partition
bool bool
_user_supports_resizing_partition(partition_id partitionID, _user_supports_resizing_partition(partition_id partitionID, int32 changeCounter,
int32 changeCounter, bool *_canResizeContents, bool *_canResizeContents, bool *_whileMounted)
bool *_whileMounted)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
@@ -523,12 +538,11 @@ _user_supports_resizing_partition(partition_id partitionID,
return result; return result;
} }
// _user_supports_moving_partition // _user_supports_moving_partition
bool bool
_user_supports_moving_partition(partition_id partitionID, int32 changeCounter, _user_supports_moving_partition(partition_id partitionID, int32 changeCounter,
partition_id *_unmovable, partition_id *_unmovable, partition_id *_needUnmounting, size_t bufferSize)
partition_id *_needUnmounting,
size_t bufferSize)
{ {
if ((!_unmovable || !_needUnmounting) && bufferSize > 0) if ((!_unmovable || !_needUnmounting) && bufferSize > 0)
return false; return false;
@@ -555,10 +569,10 @@ _user_supports_moving_partition(partition_id partitionID, int32 changeCounter,
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
result = check_shadow_partition(partition, changeCounter) result = check_shadow_partition(partition, changeCounter)
&& partition->Parent(); && partition->Parent();
if (result) { if (result) {
result = !partition->Parent()->IsBusy() result = !partition->Parent()->IsBusy()
&& !partition->Parent()->IsDescendantBusy(); && !partition->Parent()->IsDescendantBusy();
} }
if (result) { if (result) {
// get the parent disk system // get the parent disk system
@@ -574,8 +588,7 @@ _user_supports_moving_partition(partition_id partitionID, int32 changeCounter,
size_t unmovableSize = bufferSize; size_t unmovableSize = bufferSize;
size_t needUnmountingSize = bufferSize; size_t needUnmountingSize = bufferSize;
result = get_unmovable_descendants(partition, unmovable, result = get_unmovable_descendants(partition, unmovable,
unmovableSize, needUnmounting, unmovableSize, needUnmounting, needUnmountingSize);
needUnmountingSize);
} }
} }
} }
@@ -588,10 +601,11 @@ _user_supports_moving_partition(partition_id partitionID, int32 changeCounter,
return result; return result;
} }
// _user_supports_setting_partition_name // _user_supports_setting_partition_name
bool bool
_user_supports_setting_partition_name(partition_id partitionID, _user_supports_setting_partition_name(partition_id partitionID,
int32 changeCounter) int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -623,8 +637,7 @@ _user_supports_setting_partition_name(partition_id partitionID,
// _user_supports_setting_partition_content_name // _user_supports_setting_partition_content_name
bool bool
_user_supports_setting_partition_content_name(partition_id partitionID, _user_supports_setting_partition_content_name(partition_id partitionID,
int32 changeCounter, int32 changeCounter, bool *_whileMounted)
bool *_whileMounted)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -658,10 +671,11 @@ _user_supports_setting_partition_content_name(partition_id partitionID,
return result; return result;
} }
// _user_supports_setting_partition_type // _user_supports_setting_partition_type
bool bool
_user_supports_setting_partition_type(partition_id partitionID, _user_supports_setting_partition_type(partition_id partitionID,
int32 changeCounter) int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -688,10 +702,11 @@ _user_supports_setting_partition_type(partition_id partitionID,
B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE); B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE);
} }
// _user_supports_setting_partition_parameters // _user_supports_setting_partition_parameters
bool bool
_user_supports_setting_partition_parameters(partition_id partitionID, _user_supports_setting_partition_parameters(partition_id partitionID,
int32 changeCounter) int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -718,11 +733,11 @@ _user_supports_setting_partition_parameters(partition_id partitionID,
B_DISK_SYSTEM_SUPPORTS_SETTING_PARAMETERS); B_DISK_SYSTEM_SUPPORTS_SETTING_PARAMETERS);
} }
// _user_supports_setting_partition_content_parameters // _user_supports_setting_partition_content_parameters
bool bool
_user_supports_setting_partition_content_parameters(partition_id partitionID, _user_supports_setting_partition_content_parameters(partition_id partitionID,
int32 changeCounter, int32 changeCounter, bool *_whileMounted)
bool *_whileMounted)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -754,11 +769,11 @@ _user_supports_setting_partition_content_parameters(partition_id partitionID,
return result; return result;
} }
// _user_supports_initializing_partition // _user_supports_initializing_partition
bool bool
_user_supports_initializing_partition(partition_id partitionID, _user_supports_initializing_partition(partition_id partitionID,
int32 changeCounter, int32 changeCounter, const char *_diskSystemName)
const char *_diskSystemName)
{ {
if (!_diskSystemName) if (!_diskSystemName)
return false; return false;
@@ -806,10 +821,11 @@ _user_supports_initializing_partition(partition_id partitionID,
diskSystemName); diskSystemName);
} }
// _user_supports_creating_child_partition // _user_supports_creating_child_partition
bool bool
_user_supports_creating_child_partition(partition_id partitionID, _user_supports_creating_child_partition(partition_id partitionID,
int32 changeCounter) int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -832,10 +848,11 @@ _user_supports_creating_child_partition(partition_id partitionID,
B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD); B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD);
} }
// _user_supports_deleting_child_partition // _user_supports_deleting_child_partition
bool bool
_user_supports_deleting_child_partition(partition_id partitionID, _user_supports_deleting_child_partition(partition_id partitionID,
int32 changeCounter) int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -848,10 +865,11 @@ _user_supports_deleting_child_partition(partition_id partitionID,
return (validate_delete_child_partition(partition, changeCounter) == B_OK); return (validate_delete_child_partition(partition, changeCounter) == B_OK);
} }
// _user_is_sub_disk_system_for // _user_is_sub_disk_system_for
bool bool
_user_is_sub_disk_system_for(disk_system_id diskSystemID, _user_is_sub_disk_system_for(disk_system_id diskSystemID,
partition_id partitionID, int32 changeCounter) partition_id partitionID, int32 changeCounter)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -871,10 +889,11 @@ _user_is_sub_disk_system_for(disk_system_id diskSystemID,
return diskSystem->IsSubSystemFor(partition); return diskSystem->IsSubSystemFor(partition);
} }
// _user_validate_resize_partition // _user_validate_resize_partition
status_t status_t
_user_validate_resize_partition(partition_id partitionID, int32 changeCounter, _user_validate_resize_partition(partition_id partitionID, int32 changeCounter,
off_t *_size) off_t *_size)
{ {
if (!_size) if (!_size)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -890,16 +909,17 @@ _user_validate_resize_partition(partition_id partitionID, int32 changeCounter,
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
off_t contentSize = 0; off_t contentSize = 0;
bool result = validate_resize_partition(partition, changeCounter, &size, bool result = validate_resize_partition(partition, changeCounter, &size,
&contentSize); &contentSize);
if (result) if (result)
user_memcpy(_size, &size, sizeof(size)); user_memcpy(_size, &size, sizeof(size));
return result; return result;
} }
// _user_validate_move_partition // _user_validate_move_partition
status_t status_t
_user_validate_move_partition(partition_id partitionID, int32 changeCounter, _user_validate_move_partition(partition_id partitionID, int32 changeCounter,
off_t *_newOffset) off_t *_newOffset)
{ {
if (!_newOffset) if (!_newOffset)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -913,16 +933,18 @@ _user_validate_move_partition(partition_id partitionID, int32 changeCounter,
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
status_t result = validate_move_partition(partition, changeCounter, &newOffset); status_t result = validate_move_partition(partition, changeCounter,
&newOffset);
if (result) if (result)
user_memcpy(_newOffset, &newOffset, sizeof(newOffset)); user_memcpy(_newOffset, &newOffset, sizeof(newOffset));
return result; return result;
} }
// _user_validate_set_partition_name // _user_validate_set_partition_name
status_t status_t
_user_validate_set_partition_name(partition_id partitionID, _user_validate_set_partition_name(partition_id partitionID,
int32 changeCounter, char *_name) int32 changeCounter, char *_name)
{ {
if (!_name) if (!_name)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -944,6 +966,7 @@ _user_validate_set_partition_name(partition_id partitionID,
return error; return error;
} }
// _user_validate_set_partition_content_name // _user_validate_set_partition_content_name
status_t status_t
_user_validate_set_partition_content_name(partition_id partitionID, _user_validate_set_partition_content_name(partition_id partitionID,
@@ -969,10 +992,11 @@ _user_validate_set_partition_content_name(partition_id partitionID,
return error; return error;
} }
// _user_validate_set_partition_type // _user_validate_set_partition_type
status_t status_t
_user_validate_set_partition_type(partition_id partitionID, _user_validate_set_partition_type(partition_id partitionID,
int32 changeCounter, const char *_type) int32 changeCounter, const char *_type)
{ {
if (!_type) if (!_type)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -991,20 +1015,22 @@ _user_validate_set_partition_type(partition_id partitionID,
return validate_set_partition_type(partition, changeCounter, type); return validate_set_partition_type(partition, changeCounter, type);
} }
// _user_validate_initialize_partition // _user_validate_initialize_partition
status_t status_t
_user_validate_initialize_partition(partition_id partitionID, _user_validate_initialize_partition(partition_id partitionID,
int32 changeCounter, int32 changeCounter, const char *_diskSystemName, char *_name,
const char *_diskSystemName, char *_name, const char *_parameters, size_t parametersSize)
const char *_parameters,
size_t parametersSize)
{ {
if (!_diskSystemName || !_name || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) if (!_diskSystemName || !_name
|| parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) {
return B_BAD_VALUE; return B_BAD_VALUE;
}
char diskSystemName[B_DISK_SYSTEM_NAME_LENGTH]; char diskSystemName[B_DISK_SYSTEM_NAME_LENGTH];
char name[B_DISK_DEVICE_NAME_LENGTH]; char name[B_DISK_DEVICE_NAME_LENGTH];
char *parameters = NULL; char *parameters = NULL;
status_t error = ddm_strlcpy(diskSystemName, _diskSystemName, B_DISK_SYSTEM_NAME_LENGTH); status_t error = ddm_strlcpy(diskSystemName, _diskSystemName,
B_DISK_SYSTEM_NAME_LENGTH);
if (!error) if (!error)
error = ddm_strlcpy(name, _name, B_DISK_DEVICE_NAME_LENGTH, true); error = ddm_strlcpy(name, _name, B_DISK_DEVICE_NAME_LENGTH, true);
if (error) if (error)
@@ -1019,13 +1045,13 @@ _user_validate_initialize_partition(partition_id partitionID,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->ReadLockPartition(partitionID); KPartition *partition = manager->ReadLockPartition(partitionID);
error = partition ? B_OK : B_ENTRY_NOT_FOUND; error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
error = validate_initialize_partition(partition, changeCounter, error = validate_initialize_partition(partition, changeCounter,
diskSystemName, name, parameters); diskSystemName, name, parameters);
} }
if (!error) if (!error)
error = ddm_strlcpy(_name, name, B_DISK_DEVICE_NAME_LENGTH); error = ddm_strlcpy(_name, name, B_DISK_DEVICE_NAME_LENGTH);
@@ -1033,17 +1059,15 @@ _user_validate_initialize_partition(partition_id partitionID,
return error; return error;
} }
// _user_validate_create_child_partition // _user_validate_create_child_partition
status_t status_t
_user_validate_create_child_partition(partition_id partitionID, _user_validate_create_child_partition(partition_id partitionID,
int32 changeCounter, off_t *_offset, int32 changeCounter, off_t *_offset, off_t *_size, const char *_type,
off_t *_size, const char *_type, const char *_parameters, size_t parametersSize)
const char *_parameters,
size_t parametersSize)
{ {
if (!_offset || !_size || !_type if (!_offset || !_size || !_type
|| parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) {
{
return B_BAD_VALUE; return B_BAD_VALUE;
} }
off_t offset; off_t offset;
@@ -1065,13 +1089,13 @@ _user_validate_create_child_partition(partition_id partitionID,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->ReadLockPartition(partitionID); KPartition *partition = manager->ReadLockPartition(partitionID);
error = partition ? B_OK : B_ENTRY_NOT_FOUND; error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
error = validate_create_child_partition(partition, changeCounter, &offset, error = validate_create_child_partition(partition, changeCounter,
&size, type, parameters); &offset, &size, type, parameters);
} }
if (!error) { if (!error) {
user_memcpy(_offset, &offset, sizeof(offset)); user_memcpy(_offset, &offset, sizeof(offset));
@@ -1081,11 +1105,11 @@ _user_validate_create_child_partition(partition_id partitionID,
return error; return error;
} }
// _user_get_next_supported_partition_type // _user_get_next_supported_partition_type
status_t status_t
_user_get_next_supported_partition_type(partition_id partitionID, _user_get_next_supported_partition_type(partition_id partitionID,
int32 changeCounter, int32 *_cookie, int32 changeCounter, int32 *_cookie, char *_type)
char *_type)
{ {
if (!_cookie || !_type) if (!_cookie || !_type)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1094,20 +1118,22 @@ _user_get_next_supported_partition_type(partition_id partitionID,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->ReadLockPartition(partitionID); KPartition *partition = manager->ReadLockPartition(partitionID);
status_t error = partition ? B_OK : B_ENTRY_NOT_FOUND; status_t error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceReadLocker locker(partition->Device(), true); DeviceReadLocker locker(partition->Device(), true);
error = check_shadow_partition(partition, changeCounter) ? B_OK : B_BAD_VALUE; error = check_shadow_partition(partition, changeCounter)
? B_OK : B_BAD_VALUE;
if (!error) { if (!error) {
// get the disk system // get the disk system
KDiskSystem *diskSystem = partition->DiskSystem(); KDiskSystem *diskSystem = partition->DiskSystem();
error = diskSystem ? B_OK : B_ENTRY_NOT_FOUND; error = diskSystem ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
// get the info // get the info
char type[B_DISK_DEVICE_TYPE_LENGTH]; char type[B_DISK_DEVICE_TYPE_LENGTH];
error = diskSystem->GetNextSupportedType(partition, &cookie, type); error = diskSystem->GetNextSupportedType(partition, &cookie,
type);
if (!error) { if (!error) {
error = ddm_strlcpy(_type, type, B_DISK_DEVICE_TYPE_LENGTH); error = ddm_strlcpy(_type, type, B_DISK_DEVICE_TYPE_LENGTH);
} }
@@ -1119,15 +1145,17 @@ _user_get_next_supported_partition_type(partition_id partitionID,
return error; return error;
} }
// _user_get_partition_type_for_content_type // _user_get_partition_type_for_content_type
status_t status_t
_user_get_partition_type_for_content_type(disk_system_id diskSystemID, _user_get_partition_type_for_content_type(disk_system_id diskSystemID,
const char *_contentType, char *_type) const char *_contentType, char *_type)
{ {
if (!_contentType || !_type) if (!_contentType || !_type)
return B_BAD_VALUE; return B_BAD_VALUE;
char contentType[B_DISK_DEVICE_TYPE_LENGTH]; char contentType[B_DISK_DEVICE_TYPE_LENGTH];
status_t error = ddm_strlcpy(contentType, _contentType, B_DISK_DEVICE_TYPE_LENGTH); status_t error = ddm_strlcpy(contentType, _contentType,
B_DISK_DEVICE_TYPE_LENGTH);
if (error) if (error)
return error; return error;
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
@@ -1138,12 +1166,12 @@ _user_get_partition_type_for_content_type(disk_system_id diskSystemID,
DiskSystemLoader loader(diskSystem, true); DiskSystemLoader loader(diskSystem, true);
// get the info // get the info
char type[B_DISK_DEVICE_TYPE_LENGTH]; char type[B_DISK_DEVICE_TYPE_LENGTH];
if (diskSystem->GetTypeForContentType(contentType, type)) { if (diskSystem->GetTypeForContentType(contentType, type))
return ddm_strlcpy(_type, type, B_DISK_DEVICE_TYPE_LENGTH); return ddm_strlcpy(_type, type, B_DISK_DEVICE_TYPE_LENGTH);
}
return B_ERROR; return B_ERROR;
} }
// _user_prepare_disk_device_modifications // _user_prepare_disk_device_modifications
status_t status_t
_user_prepare_disk_device_modifications(partition_id deviceID) _user_prepare_disk_device_modifications(partition_id deviceID)
@@ -1165,7 +1193,7 @@ _user_prepare_disk_device_modifications(partition_id deviceID)
// _user_commit_disk_device_modifications // _user_commit_disk_device_modifications
status_t status_t
_user_commit_disk_device_modifications(partition_id deviceID, port_id port, _user_commit_disk_device_modifications(partition_id deviceID, port_id port,
int32 token, bool completeProgress) int32 token, bool completeProgress)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the device // get the device
@@ -1195,6 +1223,7 @@ _user_commit_disk_device_modifications(partition_id deviceID, port_id port,
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_cancel_disk_device_modifications // _user_cancel_disk_device_modifications
status_t status_t
_user_cancel_disk_device_modifications(partition_id deviceID) _user_cancel_disk_device_modifications(partition_id deviceID)
@@ -1213,6 +1242,7 @@ _user_cancel_disk_device_modifications(partition_id deviceID)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_is_disk_device_modified // _user_is_disk_device_modified
bool bool
_user_is_disk_device_modified(partition_id deviceID) _user_is_disk_device_modified(partition_id deviceID)
@@ -1224,13 +1254,14 @@ _user_is_disk_device_modified(partition_id deviceID)
if (DeviceReadLocker locker = device) { if (DeviceReadLocker locker = device) {
// check whether there's a shadow device and whether it's changed // check whether there's a shadow device and whether it's changed
return (device->ShadowOwner() == get_current_team() return (device->ShadowOwner() == get_current_team()
&& device->ShadowPartition() && device->ShadowPartition()
&& device->ShadowPartition()->ChangeFlags() != 0); && device->ShadowPartition()->ChangeFlags() != 0);
} }
} }
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_defragment_partition // _user_defragment_partition
status_t status_t
_user_defragment_partition(partition_id partitionID, int32 changeCounter) _user_defragment_partition(partition_id partitionID, int32 changeCounter)
@@ -1252,10 +1283,11 @@ _user_defragment_partition(partition_id partitionID, int32 changeCounter)
return B_OK; return B_OK;
} }
// _user_repair_partition // _user_repair_partition
status_t status_t
_user_repair_partition(partition_id partitionID, int32 changeCounter, _user_repair_partition(partition_id partitionID, int32 changeCounter,
bool checkOnly) bool checkOnly)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -1267,7 +1299,7 @@ _user_repair_partition(partition_id partitionID, int32 changeCounter,
DeviceWriteLocker locker(partition->Device(), true); DeviceWriteLocker locker(partition->Device(), true);
// check whether the disk system supports defragmenting // check whether the disk system supports defragmenting
status_t error = validate_repair_partition(partition, changeCounter, status_t error = validate_repair_partition(partition, changeCounter,
checkOnly); checkOnly);
if (error != B_OK) if (error != B_OK)
return error; return error;
// set the respective flag // set the respective flag
@@ -1278,10 +1310,11 @@ _user_repair_partition(partition_id partitionID, int32 changeCounter,
return B_OK; return B_OK;
} }
// _user_resize_partition // _user_resize_partition
status_t status_t
_user_resize_partition(partition_id partitionID, int32 changeCounter, _user_resize_partition(partition_id partitionID, int32 changeCounter,
off_t size) off_t size)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -1297,7 +1330,7 @@ _user_resize_partition(partition_id partitionID, int32 changeCounter,
off_t proposedSize = size; off_t proposedSize = size;
off_t contentSize = 0; off_t contentSize = 0;
status_t error = validate_resize_partition(partition, changeCounter, status_t error = validate_resize_partition(partition, changeCounter,
&proposedSize, &contentSize); &proposedSize, &contentSize);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (proposedSize != size) if (proposedSize != size)
@@ -1318,10 +1351,11 @@ _user_resize_partition(partition_id partitionID, int32 changeCounter,
return error; return error;
} }
// _user_move_partition // _user_move_partition
status_t status_t
_user_move_partition(partition_id partitionID, int32 changeCounter, _user_move_partition(partition_id partitionID, int32 changeCounter,
off_t newOffset) off_t newOffset)
{ {
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
@@ -1336,7 +1370,7 @@ _user_move_partition(partition_id partitionID, int32 changeCounter,
return B_OK; return B_OK;
off_t proposedOffset = newOffset; off_t proposedOffset = newOffset;
status_t error = validate_move_partition(partition, changeCounter, status_t error = validate_move_partition(partition, changeCounter,
&proposedOffset, true); &proposedOffset, true);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (proposedOffset != newOffset) if (proposedOffset != newOffset)
@@ -1354,10 +1388,11 @@ _user_move_partition(partition_id partitionID, int32 changeCounter,
return move_descendants_contents(partition); return move_descendants_contents(partition);
} }
// _user_set_partition_name // _user_set_partition_name
status_t status_t
_user_set_partition_name(partition_id partitionID, int32 changeCounter, _user_set_partition_name(partition_id partitionID, int32 changeCounter,
const char *_name) const char *_name)
{ {
if (!_name) if (!_name)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1376,8 +1411,7 @@ _user_set_partition_name(partition_id partitionID, int32 changeCounter,
// check name // check name
char proposedName[B_DISK_DEVICE_NAME_LENGTH]; char proposedName[B_DISK_DEVICE_NAME_LENGTH];
strcpy(proposedName, name); strcpy(proposedName, name);
error = validate_set_partition_name(partition, changeCounter, error = validate_set_partition_name(partition, changeCounter, proposedName);
proposedName);
if (error != B_OK) if (error != B_OK)
return error; return error;
if (strcmp(name, proposedName)) if (strcmp(name, proposedName))
@@ -1392,10 +1426,11 @@ _user_set_partition_name(partition_id partitionID, int32 changeCounter,
partition, B_PARTITION_SET_NAME); partition, B_PARTITION_SET_NAME);
} }
// _user_set_partition_content_name // _user_set_partition_content_name
status_t status_t
_user_set_partition_content_name(partition_id partitionID, int32 changeCounter, _user_set_partition_content_name(partition_id partitionID, int32 changeCounter,
const char *_name) const char *_name)
{ {
if (!_name) if (!_name)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1430,10 +1465,11 @@ _user_set_partition_content_name(partition_id partitionID, int32 changeCounter,
partition, B_PARTITION_SET_CONTENT_NAME); partition, B_PARTITION_SET_CONTENT_NAME);
} }
// _user_set_partition_type // _user_set_partition_type
status_t status_t
_user_set_partition_type(partition_id partitionID, int32 changeCounter, _user_set_partition_type(partition_id partitionID, int32 changeCounter,
const char *_type) const char *_type)
{ {
if (!_type) if (!_type)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1450,8 +1486,7 @@ _user_set_partition_type(partition_id partitionID, int32 changeCounter,
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true); DeviceWriteLocker locker(partition->Device(), true);
// check type // check type
error = validate_set_partition_type(partition, changeCounter, error = validate_set_partition_type(partition, changeCounter, type);
type);
if (error != B_OK) if (error != B_OK)
return error; return error;
// set type // set type
@@ -1464,10 +1499,11 @@ _user_set_partition_type(partition_id partitionID, int32 changeCounter,
partition, B_PARTITION_SET_TYPE); partition, B_PARTITION_SET_TYPE);
} }
// _user_set_partition_parameters // _user_set_partition_parameters
status_t status_t
_user_set_partition_parameters(partition_id partitionID, int32 changeCounter, _user_set_partition_parameters(partition_id partitionID, int32 changeCounter,
const char *_parameters, size_t parametersSize) const char *_parameters, size_t parametersSize)
{ {
if (!_parameters || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) if (!_parameters || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1482,7 +1518,7 @@ _user_set_partition_parameters(partition_id partitionID, int32 changeCounter,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->WriteLockPartition(partitionID); KPartition *partition = manager->WriteLockPartition(partitionID);
status_t error = partition ? B_OK : B_ENTRY_NOT_FOUND; status_t error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
@@ -1496,8 +1532,9 @@ _user_set_partition_parameters(partition_id partitionID, int32 changeCounter,
if (!error) { if (!error) {
partition->Changed(B_PARTITION_CHANGED_PARAMETERS); partition->Changed(B_PARTITION_CHANGED_PARAMETERS);
// implicit partitioning system changes // implicit partitioning system changes
error = partition->Parent()->DiskSystem()->ShadowPartitionChanged( error = partition->Parent()->DiskSystem()
partition, B_PARTITION_SET_PARAMETERS); ->ShadowPartitionChanged(partition,
B_PARTITION_SET_PARAMETERS);
} }
} }
} }
@@ -1505,12 +1542,11 @@ _user_set_partition_parameters(partition_id partitionID, int32 changeCounter,
return error; return error;
} }
// _user_set_partition_content_parameters // _user_set_partition_content_parameters
status_t status_t
_user_set_partition_content_parameters(partition_id partitionID, _user_set_partition_content_parameters(partition_id partitionID,
int32 changeCounter, int32 changeCounter, const char *_parameters, size_t parametersSize)
const char *_parameters,
size_t parametersSize)
{ {
if (!_parameters || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) if (!_parameters || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1525,7 +1561,7 @@ _user_set_partition_content_parameters(partition_id partitionID,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->WriteLockPartition(partitionID); KPartition *partition = manager->WriteLockPartition(partitionID);
status_t error = partition ? B_OK : B_ENTRY_NOT_FOUND; status_t error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
@@ -1548,18 +1584,22 @@ _user_set_partition_content_parameters(partition_id partitionID,
return error; return error;
} }
// _user_initialize_partition // _user_initialize_partition
status_t status_t
_user_initialize_partition(partition_id partitionID, int32 changeCounter, _user_initialize_partition(partition_id partitionID, int32 changeCounter,
const char *_diskSystemName, const char *_name, const char *_diskSystemName, const char *_name, const char *_parameters,
const char *_parameters, size_t parametersSize) size_t parametersSize)
{ {
if (!_diskSystemName || !_name || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) if (!_diskSystemName || !_name
|| parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) {
return B_BAD_VALUE; return B_BAD_VALUE;
}
char diskSystemName[B_DISK_SYSTEM_NAME_LENGTH]; char diskSystemName[B_DISK_SYSTEM_NAME_LENGTH];
char name[B_DISK_DEVICE_NAME_LENGTH]; char name[B_DISK_DEVICE_NAME_LENGTH];
char *parameters = NULL; char *parameters = NULL;
status_t error = ddm_strlcpy(diskSystemName, _diskSystemName, B_DISK_SYSTEM_NAME_LENGTH); status_t error = ddm_strlcpy(diskSystemName, _diskSystemName,
B_DISK_SYSTEM_NAME_LENGTH);
if (!error) if (!error)
error = ddm_strlcpy(name, _name, B_DISK_DEVICE_NAME_LENGTH); error = ddm_strlcpy(name, _name, B_DISK_DEVICE_NAME_LENGTH);
if (error) if (error)
@@ -1574,14 +1614,14 @@ _user_initialize_partition(partition_id partitionID, int32 changeCounter,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->WriteLockPartition(partitionID); KPartition *partition = manager->WriteLockPartition(partitionID);
error = partition ? B_OK : B_ENTRY_NOT_FOUND; error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
DeviceWriteLocker locker(partition->Device(), true); DeviceWriteLocker locker(partition->Device(), true);
// get the disk system // get the disk system
KDiskSystem *diskSystem = manager->LoadDiskSystem(diskSystemName); KDiskSystem *diskSystem = manager->LoadDiskSystem(diskSystemName);
error = diskSystem ? B_OK : B_ENTRY_NOT_FOUND; error = diskSystem ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
DiskSystemLoader loader(diskSystem, true); DiskSystemLoader loader(diskSystem, true);
// check parameters // check parameters
@@ -1593,7 +1633,8 @@ _user_initialize_partition(partition_id partitionID, int32 changeCounter,
error = !strcmp(name, proposedName) ? B_OK : B_BAD_VALUE; error = !strcmp(name, proposedName) ? B_OK : B_BAD_VALUE;
} }
if (!error) { if (!error) {
// unitialize the partition's contents and set the new parameters // unitialize the partition's contents and set the new
// parameters
error = partition->UninitializeContents(true); error = partition->UninitializeContents(true);
} }
if (!error) { if (!error) {
@@ -1617,6 +1658,7 @@ _user_initialize_partition(partition_id partitionID, int32 changeCounter,
return error; return error;
} }
// _user_uninitialize_partition // _user_uninitialize_partition
status_t status_t
_user_uninitialize_partition(partition_id partitionID, int32 changeCounter) _user_uninitialize_partition(partition_id partitionID, int32 changeCounter)
@@ -1633,12 +1675,12 @@ _user_uninitialize_partition(partition_id partitionID, int32 changeCounter)
return partition->UninitializeContents(true); return partition->UninitializeContents(true);
} }
// _user_create_child_partition // _user_create_child_partition
status_t status_t
_user_create_child_partition(partition_id partitionID, int32 changeCounter, _user_create_child_partition(partition_id partitionID, int32 changeCounter,
off_t offset, off_t size, const char *_type, off_t offset, off_t size, const char *_type, const char *_parameters,
const char *_parameters, size_t parametersSize, size_t parametersSize, partition_id *_childID)
partition_id *_childID)
{ {
if (!_type || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE) if (!_type || parametersSize > B_DISK_DEVICE_MAX_PARAMETER_SIZE)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1657,7 +1699,7 @@ _user_create_child_partition(partition_id partitionID, int32 changeCounter,
KDiskDeviceManager *manager = KDiskDeviceManager::Default(); KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the partition // get the partition
KPartition *partition = manager->WriteLockPartition(partitionID); KPartition *partition = manager->WriteLockPartition(partitionID);
error = partition ? B_OK : B_ENTRY_NOT_FOUND; error = partition ? (status_t)B_OK : (status_t)B_ENTRY_NOT_FOUND;
if (!error) { if (!error) {
PartitionRegistrar registrar1(partition, true); PartitionRegistrar registrar1(partition, true);
PartitionRegistrar registrar2(partition->Device(), true); PartitionRegistrar registrar2(partition->Device(), true);
@@ -1701,6 +1743,7 @@ _user_create_child_partition(partition_id partitionID, int32 changeCounter,
return error; return error;
} }
// _user_delete_partition // _user_delete_partition
status_t status_t
_user_delete_partition(partition_id partitionID, int32 changeCounter) _user_delete_partition(partition_id partitionID, int32 changeCounter)
@@ -1725,10 +1768,11 @@ _user_delete_partition(partition_id partitionID, int32 changeCounter)
return B_OK; return B_OK;
} }
// _user_get_next_disk_device_job_info // _user_get_next_disk_device_job_info
status_t status_t
_user_get_next_disk_device_job_info(int32 *_cookie, _user_get_next_disk_device_job_info(int32 *_cookie,
user_disk_device_job_info *_info) user_disk_device_job_info *_info)
{ {
if (!_cookie || !_info) if (!_cookie || !_info)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1761,6 +1805,7 @@ _user_get_next_disk_device_job_info(int32 *_cookie,
return error; return error;
} }
// _user_get_disk_device_job_info // _user_get_disk_device_job_info
status_t status_t
_user_get_disk_device_job_info(disk_job_id id, user_disk_device_job_info *_info) _user_get_disk_device_job_info(disk_job_id id, user_disk_device_job_info *_info)
@@ -1780,10 +1825,11 @@ _user_get_disk_device_job_info(disk_job_id id, user_disk_device_job_info *_info)
return error; return error;
} }
// _user_get_disk_device_job_status // _user_get_disk_device_job_status
status_t status_t
_user_get_disk_device_job_progress_info(disk_job_id id, _user_get_disk_device_job_progress_info(disk_job_id id,
disk_device_job_progress_info *_info) disk_device_job_progress_info *_info)
{ {
if (!_info) if (!_info)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -1800,6 +1846,7 @@ _user_get_disk_device_job_progress_info(disk_job_id id,
return error; return error;
} }
// _user_pause_disk_device_job // _user_pause_disk_device_job
status_t status_t
_user_pause_disk_device_job(disk_job_id id) _user_pause_disk_device_job(disk_job_id id)
@@ -1819,6 +1866,7 @@ _user_pause_disk_device_job(disk_job_id id)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
// _user_cancel_disk_device_job // _user_cancel_disk_device_job
status_t status_t
_user_cancel_disk_device_job(disk_job_id id, bool reverse) _user_cancel_disk_device_job(disk_job_id id, bool reverse)