haiku/headers/private/kernel/disk_device_manager/KDiskDeviceManager.h
Axel Dörfler b4147ed317 * RescanDiskSystems() now locks the disk device manager, as it clobbers the
disk system lists.
* Added module watching; on module changes, it will now automatically rescan
  the disk systems.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@26368 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-07-10 12:21:05 +00:00

148 lines
4.2 KiB
C++

/*
* Copyright 2004-2007, Haiku, Inc. All rights reserved.
* Copyright 2003-2004, Ingo Weinhold, bonefish@cs.tu-berlin.de. All rights reserved.
*
* Distributed under the terms of the MIT License.
*/
#ifndef _K_DISK_DEVICE_MANAGER_H
#define _K_DISK_DEVICE_MANAGER_H
#include <disk_device_manager.h>
#include <Locker.h>
namespace BPrivate {
namespace DiskDevice {
class KDiskDevice;
class KDiskSystem;
class KFileDiskDevice;
class KPartition;
class KDiskDeviceManager {
public:
KDiskDeviceManager();
~KDiskDeviceManager();
status_t InitCheck() const;
// Singleton Creation, Deletion, and Access
static status_t CreateDefault();
static void DeleteDefault();
static KDiskDeviceManager *Default();
// Locking
bool Lock();
void Unlock();
// Disk Device / Partition Management
// manager must be locked
KDiskDevice *FindDevice(const char *path);
KDiskDevice *FindDevice(partition_id id, bool deviceOnly = true);
KPartition *FindPartition(const char *path);
KPartition *FindPartition(partition_id id);
KFileDiskDevice *FindFileDevice(const char *filePath);
KDiskDevice *RegisterDevice(const char *path);
KDiskDevice *RegisterDevice(partition_id id, bool deviceOnly = true);
KDiskDevice *RegisterNextDevice(int32 *cookie);
KPartition *RegisterPartition(const char *path);
KPartition *RegisterPartition(partition_id id);
KFileDiskDevice *RegisterFileDevice(const char *filePath);
KDiskDevice *ReadLockDevice(partition_id id, bool deviceOnly = true);
KDiskDevice *WriteLockDevice(partition_id id, bool deviceOnly = true);
// The device is also registered and must be unregistered by the
// caller.
KPartition *ReadLockPartition(partition_id id);
KPartition *WriteLockPartition(partition_id id);
// Both the device and the partition is also registered and must be
// unregistered by the caller.
status_t ScanPartition(KPartition* partition);
partition_id CreateDevice(const char *path, bool *newlyCreated = NULL);
status_t DeleteDevice(const char *path);
partition_id CreateFileDevice(const char* filePath,
bool* newlyCreated = NULL);
status_t DeleteFileDevice(const char *filePath);
status_t DeleteFileDevice(partition_id id);
// manager must be locked
int32 CountDevices();
KDiskDevice *NextDevice(int32 *cookie);
bool PartitionAdded(KPartition *partition); // implementation internal
bool PartitionRemoved(KPartition *partition); //
bool DeletePartition(KPartition *partition); //
// Disk Systems
// manager must be locked
KDiskSystem *FindDiskSystem(const char *name, bool byPrettyName = false);
KDiskSystem *FindDiskSystem(disk_system_id id);
int32 CountDiskSystems();
KDiskSystem *NextDiskSystem(int32 *cookie);
KDiskSystem *LoadDiskSystem(const char *name, bool byPrettyName = false);
KDiskSystem *LoadDiskSystem(disk_system_id id);
KDiskSystem *LoadNextDiskSystem(int32 *cookie);
status_t InitialDeviceScan();
status_t RescanDiskSystems();
status_t StartMonitoring();
private:
struct DeviceMap;
struct DiskSystemMap;
struct PartitionMap;
struct PartitionSet;
class DiskSystemWatcher;
class DeviceWatcher;
static status_t _CheckMediaStatusDaemon(void* self);
status_t _CheckMediaStatus();
status_t _RescanDiskSystems(DiskSystemMap& addedSystems, bool fileSystems);
status_t _AddPartitioningSystem(const char *name);
status_t _AddFileSystem(const char *name);
status_t _AddDiskSystem(KDiskSystem *diskSystem);
bool _AddDevice(KDiskDevice *device);
bool _RemoveDevice(KDiskDevice *device);
status_t _Scan(const char *path);
status_t _ScanPartition(KPartition *partition, bool async,
DiskSystemMap* restrictScan = NULL);
// the manager must be locked and the device write locked
status_t _ScanPartition(KPartition *partition,
DiskSystemMap* restrictScan);
status_t _AddRemoveMonitoring(const char *path, bool add);
BLocker fLock;
DeviceMap *fDevices;
PartitionMap *fPartitions;
DiskSystemMap *fDiskSystems;
PartitionSet *fObsoletePartitions;
thread_id fMediaChecker;
volatile bool fTerminating;
DiskSystemWatcher *fDiskSystemWatcher;
DeviceWatcher *fDeviceWatcher;
static KDiskDeviceManager *sDefaultManager;
};
} // namespace DiskDevice
} // namespace BPrivate
using BPrivate::DiskDevice::KDiskDeviceManager;
#endif // _K_DISK_DEVICE_MANAGER_H