RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-25 13:05:07 +00:00
Code Issues Activity Actions

Revert "Kernel: Implement an asynchronous device request stack"

Browse source 
This reverts commit 2fd5ce1eb0.

This broke booting without SMP. (PR was #3921)
This commit is contained in:
Andreas Kling 2020-11-04 21:25:26 +01:00
parent 70eaadc1cd
commit 501cef2bd7
17 changed files with 245 additions and 803 deletions
Download patch file Download diff file Expand all files Collapse all files

124
Kernel/Devices/PATADiskDevice.cpp
View file

@ -55,10 +55,22 @@ const char* PATADiskDevice::class_name() const
return "PATADiskDevice";
}
void PATADiskDevice::start_request(AsyncBlockDeviceRequest& request)
bool PATADiskDevice::read_blocks(unsigned index, u16 count, UserOrKernelBuffer& out)
{
bool use_dma = !m_channel.m_bus_master_base.is_null() && m_channel.m_dma_enabled.resource();
m_channel.start_request(request, use_dma, is_slave());
if (!m_channel.m_bus_master_base.is_null() && m_channel.m_dma_enabled.resource())
return read_sectors_with_dma(index, count, out);
return read_sectors(index, count, out);
}
bool PATADiskDevice::write_blocks(unsigned index, u16 count, const UserOrKernelBuffer& data)
{
if (!m_channel.m_bus_master_base.is_null() && m_channel.m_dma_enabled.resource())
return write_sectors_with_dma(index, count, data);
for (unsigned i = 0; i < count; ++i) {
if (!write_sectors(index + i, 1, data.offset(i * 512)))
return false;
}
return true;
}
void PATADiskDevice::set_drive_geometry(u16 cyls, u16 heads, u16 spt)
@ -88,19 +100,8 @@ KResultOr<size_t> PATADiskDevice::read(FileDescription&, size_t offset, UserOrKe
#endif
if (whole_blocks > 0) {
auto read_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Read, index, whole_blocks, outbuf, whole_blocks * block_size());
auto result = read_request->wait();
if (result.wait_result().was_interrupted())
return KResult(-EINTR);
switch (result.request_result()) {
case AsyncDeviceRequest::Failure:
case AsyncDeviceRequest::Cancelled:
return KResult(-EIO);
case AsyncDeviceRequest::MemoryFault:
return KResult(-EFAULT);
default:
break;
}
if (!read_blocks(index, whole_blocks, outbuf))
return -1;
}
off_t pos = whole_blocks * block_size();
@ -108,21 +109,8 @@ KResultOr<size_t> PATADiskDevice::read(FileDescription&, size_t offset, UserOrKe
if (remaining > 0) {
auto data = ByteBuffer::create_uninitialized(block_size());
auto data_buffer = UserOrKernelBuffer::for_kernel_buffer(data.data());
auto read_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Read, index + whole_blocks, 1, data_buffer, block_size());
auto result = read_request->wait();
if (result.wait_result().was_interrupted())
return KResult(-EINTR);
switch (result.request_result()) {
case AsyncDeviceRequest::Failure:
if (!read_blocks(index + whole_blocks, 1, data_buffer))
return pos;
case AsyncDeviceRequest::Cancelled:
return KResult(-EIO);
case AsyncDeviceRequest::MemoryFault:
// This should never happen, we're writing to a kernel buffer!
ASSERT_NOT_REACHED();
default:
break;
}
if (!outbuf.write(data.data(), pos, remaining))
return KResult(-EFAULT);
}
@ -155,19 +143,8 @@ KResultOr<size_t> PATADiskDevice::write(FileDescription&, size_t offset, const U
#endif
if (whole_blocks > 0) {
auto write_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Write, index, whole_blocks, inbuf, whole_blocks * block_size());
auto result = write_request->wait();
if (result.wait_result().was_interrupted())
return KResult(-EINTR);
switch (result.request_result()) {
case AsyncDeviceRequest::Failure:
case AsyncDeviceRequest::Cancelled:
return KResult(-EIO);
case AsyncDeviceRequest::MemoryFault:
return KResult(-EFAULT);
default:
break;
}
if (!write_blocks(index, whole_blocks, inbuf))
return -1;
}
off_t pos = whole_blocks * block_size();
@ -178,45 +155,12 @@ KResultOr<size_t> PATADiskDevice::write(FileDescription&, size_t offset, const U
if (remaining > 0) {
auto data = ByteBuffer::create_zeroed(block_size());
auto data_buffer = UserOrKernelBuffer::for_kernel_buffer(data.data());
{
auto read_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Read, index + whole_blocks, 1, data_buffer, block_size());
auto result = read_request->wait();
if (result.wait_result().was_interrupted())
return KResult(-EINTR);
switch (result.request_result()) {
case AsyncDeviceRequest::Failure:
return pos;
case AsyncDeviceRequest::Cancelled:
return KResult(-EIO);
case AsyncDeviceRequest::MemoryFault:
// This should never happen, we're writing to a kernel buffer!
ASSERT_NOT_REACHED();
default:
break;
}
}
if (!read_blocks(index + whole_blocks, 1, data_buffer))
return pos;
if (!inbuf.read(data.data(), pos, remaining))
return KResult(-EFAULT);
{
auto write_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Write, index + whole_blocks, 1, data_buffer, block_size());
auto result = write_request->wait();
if (result.wait_result().was_interrupted())
return KResult(-EINTR);
switch (result.request_result()) {
case AsyncDeviceRequest::Failure:
return pos;
case AsyncDeviceRequest::Cancelled:
return KResult(-EIO);
case AsyncDeviceRequest::MemoryFault:
// This should never happen, we're writing to a kernel buffer!
ASSERT_NOT_REACHED();
default:
break;
}
}
if (!write_blocks(index + whole_blocks, 1, data_buffer))
return pos;
}
return pos + remaining;
@ -227,6 +171,26 @@ bool PATADiskDevice::can_write(const FileDescription&, size_t offset) const
return offset < (m_cylinders * m_heads * m_sectors_per_track * block_size());
}
bool PATADiskDevice::read_sectors_with_dma(u32 lba, u16 count, UserOrKernelBuffer& outbuf)
{
return m_channel.ata_read_sectors_with_dma(lba, count, outbuf, is_slave());
}
bool PATADiskDevice::read_sectors(u32 start_sector, u16 count, UserOrKernelBuffer& outbuf)
{
return m_channel.ata_read_sectors(start_sector, count, outbuf, is_slave());
}
bool PATADiskDevice::write_sectors_with_dma(u32 lba, u16 count, const UserOrKernelBuffer& inbuf)
{
return m_channel.ata_write_sectors_with_dma(lba, count, inbuf, is_slave());
}
bool PATADiskDevice::write_sectors(u32 start_sector, u16 count, const UserOrKernelBuffer& inbuf)
{
return m_channel.ata_write_sectors(start_sector, count, inbuf, is_slave());
}
bool PATADiskDevice::is_slave() const
{
return m_drive_type == DriveType::Slave;