Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Added shadow_id field to user_partition_data.

Browse Source 
* Implemented several new syscalls (_kern_find_{disk_device,partition}(),
  {prepare,cancel}_disk_device_modifications(),
  [un]register_file_device()),


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@3982 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold 2003-07-15 01:27:43 +00:00
parent 7fcdfb5fb8
commit 1ff134b901
1 changed files with 154 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
src/kernel/core/disk_device_manager/ddm_userland_interface.cpp
View File

@ -3,24 +3,92 @@
#include <KDiskDevice.h>
#include <KDiskDeviceManager.h>
#include <KDiskDeviceUtils.h>
#include <KFileDiskDevice.h>
#include <KDiskSystem.h>
#include "ddm_userland_interface.h"
#include "UserDataWriter.h"
// get_current_team
team_id
get_current_team()
{
// TODO: There must be a straighter way in kernelland.
thread_info info;
get_thread_info(find_thread(NULL), &info);
return info.team;
}
// _kern_get_next_disk_device_id
partition_id
_kern_get_next_disk_device_id(int32 *cookie, size_t *neededSize)
{
if (!cookie)
return B_BAD_VALUE;
partition_id id = B_ERROR;
partition_id id = B_ENTRY_NOT_FOUND;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the next device
if (KDiskDevice *device = manager->RegisterNextDevice(cookie)) {
PartitionRegistrar _(device, true);
id = device->ID();
if (neededSize) {
if (DeviceReadLocker locker = device) {
// get the needed size
UserDataWriter writer;
device->WriteUserData(writer, false);
*neededSize = writer.AllocatedSize();
} else
return B_ERROR;
}
}
return id;
}
// _kern_find_disk_device
partition_id
_kern_find_disk_device(const char *filename, size_t *neededSize)
{
if (!filename)
return B_BAD_VALUE;
partition_id id = B_ENTRY_NOT_FOUND;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// find the device
if (KDiskDevice *device = manager->RegisterDevice(filename)) {
PartitionRegistrar _(device, true);
id = device->ID();
if (neededSize) {
if (DeviceReadLocker locker = device) {
// get the needed size
UserDataWriter writer;
device->WriteUserData(writer, false);
*neededSize = writer.AllocatedSize();
} else
return B_ERROR;
}
}
return id;
}
// _kern_find_partition
partition_id
_kern_find_partition(const char *filename, size_t *neededSize)
{
if (!filename)
return B_BAD_VALUE;
partition_id id = B_ENTRY_NOT_FOUND;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// find the partition
if (KPartition *partition = manager->RegisterPartition(filename)) {
PartitionRegistrar _(partition, true);
id = partition->ID();
if (neededSize) {
// get and lock the partition's device
KDiskDevice *device = manager->RegisterDevice(partition->ID());
if (!device)
return B_ENTRY_NOT_FOUND;
PartitionRegistrar _2(device, true);
if (DeviceReadLocker locker = device) {
// get the needed size
UserDataWriter writer;
device->WriteUserData(writer, false);
*neededSize = writer.AllocatedSize();
@ -33,27 +101,57 @@ _kern_get_next_disk_device_id(int32 *cookie, size_t *neededSize)
// _kern_get_disk_device_data
status_t
_kern_get_disk_device_data(partition_id deviceID, bool shadow,
_kern_get_disk_device_data(partition_id id, bool deviceOnly, bool shadow,
user_disk_device_data *buffer, size_t bufferSize,
size_t *neededSize)
{
if (!buffer && bufferSize > 0)
return B_BAD_VALUE;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
if (KDiskDevice *device = manager->RegisterDevice(deviceID)) {
// get the device
if (KDiskDevice *device = manager->RegisterDevice(id, deviceOnly)) {
PartitionRegistrar _(device, true);
if (DeviceReadLocker locker = device) {
// write the device data into the buffer
UserDataWriter writer(buffer, bufferSize);
device->WriteUserData(writer, shadow);
if (neededSize)
*neededSize = writer.AllocatedSize();
if (writer.AllocatedSize() <= bufferSize)
return B_OK;
return B_BUFFER_OVERFLOW;
}
}
return B_ENTRY_NOT_FOUND;
}
// _kern_register_file_device
partition_id
_kern_register_file_device(const char *filename)
{
if (!filename)
return B_BAD_VALUE;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
if (ManagerLocker locker = manager) {
if (KFileDiskDevice *device = manager->FindFileDevice(filename))
return device->ID();
return manager->CreateFileDevice(filename);
}
return B_ERROR;
}
// _kern_unregister_file_device
status_t
_kern_unregister_file_device(partition_id deviceID, const char *filename)
{
if (deviceID < 0 && !filename)
return B_BAD_VALUE;
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
if (deviceID >= 0)
return manager->DeleteFileDevice(deviceID);
return manager->DeleteFileDevice(filename);
}
// _kern_get_disk_system_info
status_t
_kern_get_disk_system_info(disk_system_id id, user_disk_system_info *info)
@ -105,3 +203,56 @@ _kern_find_disk_system(const char *name, user_disk_system_info *info)
return B_ENTRY_NOT_FOUND;
}
// _kern_prepare_disk_device_modifications
status_t
_kern_prepare_disk_device_modifications(partition_id deviceID)
{
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the device
if (KDiskDevice *device = manager->RegisterDevice(deviceID, true)) {
PartitionRegistrar _(device, true);
if (DeviceWriteLocker locker = device) {
if (device->ShadowOwner() >= 0)
return B_BUSY;
// create shadow device
return device->CreateShadowDevice(get_current_team());
}
}
return B_ENTRY_NOT_FOUND;
}
// _kern_commit_disk_device_modifications
status_t
_kern_commit_disk_device_modifications(partition_id deviceID, port_id port,
int32 token, bool completeProgress)
{
// not implemented
return B_ERROR;
}
// _kern_cancel_disk_device_modifications
status_t
_kern_cancel_disk_device_modifications(partition_id deviceID)
{
KDiskDeviceManager *manager = KDiskDeviceManager::Default();
// get the device
if (KDiskDevice *device = manager->RegisterDevice(deviceID, true)) {
PartitionRegistrar _(device, true);
if (DeviceWriteLocker locker = device) {
if (device->ShadowOwner() != get_current_team())
return B_BAD_VALUE;
// delete shadow device
return device->DeleteShadowDevice();
}
}
return B_ENTRY_NOT_FOUND;
}
// _kern_is_disk_device_modified
bool
_kern_is_disk_device_modified(partition_id device)
{
// not implemented
return false;
}