RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-24 21:07:34 +00:00
Code Issues Activity Actions

Kernel: Refactor storage stack with u64 as number of blocks

Browse source
This commit is contained in:
Jean-Baptiste Boric 2021-03-16 20:23:16 +01:00 • committed by Andreas Kling
parent aeef14ae28
commit 9a3aa7eb0b
10 changed files with 26 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kernel/Storage/AHCIPort.cpp
View file

@ -243,7 +243,7 @@ bool AHCIPort::initialize()
size_t logical_sector_size = 512; size_t logical_sector_size = 512;
size_t physical_sector_size = 512; size_t physical_sector_size = 512;
size_t max_addressable_sector = 0; u64 max_addressable_sector = 0;
if (identify_device()) { if (identify_device()) {
auto identify_block = map_typed<ATAIdentifyBlock>(m_parent_handler->get_identify_metadata_physical_region(m_port_index)); auto identify_block = map_typed<ATAIdentifyBlock>(m_parent_handler->get_identify_metadata_physical_region(m_port_index));
// Check if word 106 is valid before using it! // Check if word 106 is valid before using it!
@ -266,7 +266,7 @@ bool AHCIPort::initialize()
m_port_registers.cmd = m_port_registers.cmd | (1 << 24); m_port_registers.cmd = m_port_registers.cmd | (1 << 24);
} }
dmesgln("AHCI Port {}: max lba {:x}, L/P sector size - {}/{} ", representative_port_index(), max_addressable_sector, logical_sector_size, physical_sector_size); dmesgln("AHCI Port {}: Device found, Capacity={}, Bytes per logical sector={}, Bytes per physical sector={}", representative_port_index(), max_addressable_sector * logical_sector_size, logical_sector_size, physical_sector_size);
// FIXME: We don't support ATAPI devices yet, so for now we don't "create" them // FIXME: We don't support ATAPI devices yet, so for now we don't "create" them
if (!is_atapi_attached()) { if (!is_atapi_attached()) {

9
Kernel/Storage/IDEChannel.cpp
View file

@ -388,12 +388,15 @@ UNMAP_AFTER_INIT void IDEChannel::detect_disks()
u16 capabilities = wbufbase[ATA_IDENT_CAPABILITIES / sizeof(u16)]; u16 capabilities = wbufbase[ATA_IDENT_CAPABILITIES / sizeof(u16)];
if (cyls == 0 || heads == 0 || spt == 0) if (cyls == 0 || heads == 0 || spt == 0)
continue; continue;
dbgln("IDEChannel: {} {} device found: Type={}, Name={}, C/H/Spt={}/{}/{}, Capabilities=0x{:04x}", channel_type_string(), channel_string(i), interface_type == PATADiskDevice::InterfaceType::ATA ? "ATA" : "ATAPI", ((char*)bbuf.data() + 54), cyls, heads, spt, capabilities); u64 max_addressable_block = cyls * heads * spt;
if (capabilities & ATA_CAP_LBA)
max_addressable_block = (wbufbase[(ATA_IDENT_MAX_LBA + 2) / sizeof(u16)] << 16) | wbufbase[ATA_IDENT_MAX_LBA / sizeof(u16)];
dbgln("IDEChannel: {} {} {} device found: Name={}, Capacity={}, C/H/Spt={}/{}/{}, Capabilities=0x{:04x}", channel_type_string(), channel_string(i), interface_type == PATADiskDevice::InterfaceType::ATA ? "ATA" : "ATAPI", ((char*)bbuf.data() + 54), max_addressable_block * 512, cyls, heads, spt, capabilities);
if (i == 0) { if (i == 0) {
m_master = PATADiskDevice::create(m_parent_controller, *this, PATADiskDevice::DriveType::Master, interface_type, cyls, heads, spt, capabilities); m_master = PATADiskDevice::create(m_parent_controller, *this, PATADiskDevice::DriveType::Master, interface_type, capabilities, max_addressable_block);
} else { } else {
m_slave = PATADiskDevice::create(m_parent_controller, *this, PATADiskDevice::DriveType::Slave, interface_type, cyls, heads, spt, capabilities); m_slave = PATADiskDevice::create(m_parent_controller, *this, PATADiskDevice::DriveType::Slave, interface_type, capabilities, max_addressable_block);
} }
} }
} }

16
Kernel/Storage/PATADiskDevice.cpp
View file

@ -33,16 +33,13 @@
namespace Kernel { namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<PATADiskDevice> PATADiskDevice::create(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 cylinders, u16 heads, u16 spt, u16 capabilities) UNMAP_AFTER_INIT NonnullRefPtr<PATADiskDevice> PATADiskDevice::create(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 capabilities, u64 max_addressable_block)
{ {
return adopt(*new PATADiskDevice(controller, channel, type, interface_type, cylinders, heads, spt, capabilities)); return adopt(*new PATADiskDevice(controller, channel, type, interface_type, capabilities, max_addressable_block));
} }
UNMAP_AFTER_INIT PATADiskDevice::PATADiskDevice(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 cylinders, u16 heads, u16 spt, u16 capabilities) UNMAP_AFTER_INIT PATADiskDevice::PATADiskDevice(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 capabilities, u64 max_addressable_block)
: StorageDevice(controller, 512, 0) : StorageDevice(controller, 512, max_addressable_block)
, m_cylinders(cylinders)
, m_heads(heads)
, m_sectors_per_track(spt)
, m_capabilities(capabilities) , m_capabilities(capabilities)
, m_channel(channel) , m_channel(channel)
, m_drive_type(type) , m_drive_type(type)
@ -70,11 +67,6 @@ String PATADiskDevice::device_name() const
return String::formatted("hd{:c}", 'a' + minor()); return String::formatted("hd{:c}", 'a' + minor());
} }
size_t PATADiskDevice::max_addressable_block() const
{
return m_cylinders * m_heads * m_sectors_per_track;
}
bool PATADiskDevice::is_slave() const bool PATADiskDevice::is_slave() const
{ {
return m_drive_type == DriveType::Slave; return m_drive_type == DriveType::Slave;

5
Kernel/Storage/PATADiskDevice.h
View file

@ -57,19 +57,18 @@ public:
}; };
public: public:
static NonnullRefPtr<PATADiskDevice> create(const IDEController&, IDEChannel&, DriveType, InterfaceType, u16, u16, u16, u16); static NonnullRefPtr<PATADiskDevice> create(const IDEController&, IDEChannel&, DriveType, InterfaceType, u16, u64);
virtual ~PATADiskDevice() override; virtual ~PATADiskDevice() override;
// ^StorageDevice // ^StorageDevice
virtual Type type() const override { return StorageDevice::Type::IDE; } virtual Type type() const override { return StorageDevice::Type::IDE; }
virtual size_t max_addressable_block() const override;
// ^BlockDevice // ^BlockDevice
virtual void start_request(AsyncBlockDeviceRequest&) override; virtual void start_request(AsyncBlockDeviceRequest&) override;
virtual String device_name() const override; virtual String device_name() const override;
private: private:
PATADiskDevice(const IDEController&, IDEChannel&, DriveType, InterfaceType, u16, u16, u16, u16); PATADiskDevice(const IDEController&, IDEChannel&, DriveType, InterfaceType, u16, u64);
// ^DiskDevice // ^DiskDevice
virtual const char* class_name() const override; virtual const char* class_name() const override;

9
Kernel/Storage/RamdiskDevice.cpp
View file

@ -38,10 +38,10 @@ NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(const RamdiskController& cont
} }
RamdiskDevice::RamdiskDevice(const RamdiskController& controller, OwnPtr<Region>&& region, int major, int minor) RamdiskDevice::RamdiskDevice(const RamdiskController& controller, OwnPtr<Region>&& region, int major, int minor)
: StorageDevice(controller, major, minor, 512, 0) : StorageDevice(controller, major, minor, 512, m_region->size() / 512)
, m_region(move(region)) , m_region(move(region))
{ {
dmesgln("Ramdisk: Device #{} @ {}, length {}", minor, m_region->vaddr(), m_region->size()); dmesgln("Ramdisk: Device #{} @ {}, Capacity={}", minor, m_region->vaddr(), max_addressable_block() * 512);
} }
RamdiskDevice::~RamdiskDevice() RamdiskDevice::~RamdiskDevice()
@ -53,11 +53,6 @@ const char* RamdiskDevice::class_name() const
return "RamdiskDevice"; return "RamdiskDevice";
} }
size_t RamdiskDevice::max_addressable_block() const
{
return m_region->size() / 512;
}
void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request) void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request)
{ {
LOCKER(m_lock); LOCKER(m_lock);

1
Kernel/Storage/RamdiskDevice.h
View file

@ -43,7 +43,6 @@ public:
// ^StorageDevice // ^StorageDevice
virtual Type type() const override { return StorageDevice::Type::Ramdisk; } virtual Type type() const override { return StorageDevice::Type::Ramdisk; }
virtual size_t max_addressable_block() const override;
// ^BlockDevice // ^BlockDevice
virtual void start_request(AsyncBlockDeviceRequest&) override; virtual void start_request(AsyncBlockDeviceRequest&) override;

4
Kernel/Storage/SATADiskDevice.cpp
View file

@ -33,12 +33,12 @@
namespace Kernel { namespace Kernel {
NonnullRefPtr<SATADiskDevice> SATADiskDevice::create(const AHCIController& controller, const AHCIPort& port, size_t sector_size, size_t max_addressable_block) NonnullRefPtr<SATADiskDevice> SATADiskDevice::create(const AHCIController& controller, const AHCIPort& port, size_t sector_size, u64 max_addressable_block)
{ {
return adopt(*new SATADiskDevice(controller, port, sector_size, max_addressable_block)); return adopt(*new SATADiskDevice(controller, port, sector_size, max_addressable_block));
} }
SATADiskDevice::SATADiskDevice(const AHCIController& controller, const AHCIPort& port, size_t sector_size, size_t max_addressable_block) SATADiskDevice::SATADiskDevice(const AHCIController& controller, const AHCIPort& port, size_t sector_size, u64 max_addressable_block)
: StorageDevice(controller, sector_size, max_addressable_block) : StorageDevice(controller, sector_size, max_addressable_block)
, m_port(port) , m_port(port)
{ {

4
Kernel/Storage/SATADiskDevice.h
View file

@ -44,7 +44,7 @@ public:
}; };
public: public:
static NonnullRefPtr<SATADiskDevice> create(const AHCIController&, const AHCIPort&, size_t sector_size, size_t max_addressable_block); static NonnullRefPtr<SATADiskDevice> create(const AHCIController&, const AHCIPort&, size_t sector_size, u64 max_addressable_block);
virtual ~SATADiskDevice() override; virtual ~SATADiskDevice() override;
// ^StorageDevice // ^StorageDevice
@ -54,7 +54,7 @@ public:
virtual String device_name() const override; virtual String device_name() const override;
private: private:
SATADiskDevice(const AHCIController&, const AHCIPort&, size_t sector_size, size_t max_addressable_block); SATADiskDevice(const AHCIController&, const AHCIPort&, size_t sector_size, u64 max_addressable_block);
// ^DiskDevice // ^DiskDevice
virtual const char* class_name() const override; virtual const char* class_name() const override;

4
Kernel/Storage/StorageDevice.cpp
View file

@ -33,14 +33,14 @@
namespace Kernel { namespace Kernel {
StorageDevice::StorageDevice(const StorageController& controller, size_t sector_size, size_t max_addressable_block) StorageDevice::StorageDevice(const StorageController& controller, size_t sector_size, u64 max_addressable_block)
: BlockDevice(StorageManagement::major_number(), StorageManagement::minor_number(), sector_size) : BlockDevice(StorageManagement::major_number(), StorageManagement::minor_number(), sector_size)
, m_storage_controller(controller) , m_storage_controller(controller)
, m_max_addressable_block(max_addressable_block) , m_max_addressable_block(max_addressable_block)
{ {
} }
StorageDevice::StorageDevice(const StorageController& controller, int major, int minor, size_t sector_size, size_t max_addressable_block) StorageDevice::StorageDevice(const StorageController& controller, int major, int minor, size_t sector_size, u64 max_addressable_block)
: BlockDevice(major, minor, sector_size) : BlockDevice(major, minor, sector_size)
, m_storage_controller(controller) , m_storage_controller(controller)
, m_max_addressable_block(max_addressable_block) , m_max_addressable_block(max_addressable_block)

8
Kernel/Storage/StorageDevice.h
View file

@ -47,7 +47,7 @@ public:
public: public:
virtual Type type() const = 0; virtual Type type() const = 0;
virtual size_t max_addressable_block() const { return m_max_addressable_block; } virtual u64 max_addressable_block() const { return m_max_addressable_block; }
NonnullRefPtr<StorageController> controller() const; NonnullRefPtr<StorageController> controller() const;
@ -61,15 +61,15 @@ public:
virtual mode_t required_mode() const override { return 0600; } virtual mode_t required_mode() const override { return 0600; }
protected: protected:
StorageDevice(const StorageController&, size_t, size_t); StorageDevice(const StorageController&, size_t, u64);
StorageDevice(const StorageController&, int, int, size_t, size_t); StorageDevice(const StorageController&, int, int, size_t, u64);
// ^DiskDevice // ^DiskDevice
virtual const char* class_name() const override; virtual const char* class_name() const override;
private: private:
NonnullRefPtr<StorageController> m_storage_controller; NonnullRefPtr<StorageController> m_storage_controller;
NonnullRefPtrVector<DiskPartition> m_partitions; NonnullRefPtrVector<DiskPartition> m_partitions;
size_t m_max_addressable_block; u64 m_max_addressable_block;
}; };
} }