Bananymous/banan-os
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Kernel: Rework storage device and disk cache locking

Browse Source 
Syncing the disk cache no longer blocks the underlying storage device
and the disk cache itself during sync
This commit is contained in:
Bananymous
2026-01-02 17:46:36 +02:00
parent 912c5ea0bf
commit 08bfa0971e
4 changed files with 53 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
kernel/include/kernel/Storage/DiskCache.h
View File

@@ -3,6 +3,7 @@
#include <BAN/Array.h>
#include <BAN/ByteSpan.h>
#include <BAN/Vector.h>
#include <kernel/Lock/RWLock.h>
#include <kernel/Memory/Types.h>
namespace Kernel
@@ -37,9 +38,13 @@ namespace Kernel
uint64_t first_sector { 0 };
uint8_t sector_mask { 0 };
uint8_t dirty_mask { 0 };
bool syncing { false };
};
private:
RWLock m_rw_lock;
Mutex m_sync_mutex;
const size_t m_sector_size;
StorageDevice& m_device;
BAN::Vector<PageCache> m_cache;

1
kernel/include/kernel/Storage/StorageDevice.h
View File

@@ -51,7 +51,6 @@ namespace Kernel
virtual bool has_hungup_impl() const override { return false; }
private:
Mutex m_mutex;
BAN::Optional<DiskCache> m_disk_cache;
BAN::Vector<BAN::RefPtr<Partition>> m_partitions;

66
kernel/kernel/Storage/DiskCache.cpp
View File

@@ -1,3 +1,4 @@
#include <BAN/ScopeGuard.h>
#include <kernel/BootInfo.h>
#include <kernel/Memory/Heap.h>
#include <kernel/Memory/PageTable.h>
@@ -53,6 +54,8 @@ namespace Kernel
const uint64_t page_cache_offset = sector % sectors_per_page;
const uint64_t page_cache_start = sector - page_cache_offset;
RWLockRDGuard _(m_rw_lock);
const auto index = find_sector_cache_index(sector);
if (index >= m_cache.size())
return false;
@@ -78,6 +81,8 @@ namespace Kernel
const uint64_t page_cache_offset = sector % sectors_per_page;
const uint64_t page_cache_start = sector - page_cache_offset;
RWLockWRGuard _(m_rw_lock);
const auto index = find_sector_cache_index(sector);
if (index >= m_cache.size() || m_cache[index].first_sector != page_cache_start)
@@ -115,12 +120,35 @@ namespace Kernel
BAN::ErrorOr<void> DiskCache::sync_cache_index(size_t index)
{
auto& cache = m_cache[index];
if (cache.dirty_mask == 0)
return {};
LockGuard _(m_sync_mutex);
PageTable::with_fast_page(cache.paddr, [&] {
memcpy(m_sync_cache.data(), PageTable::fast_page_as_ptr(), PAGE_SIZE);
PageCache temp_cache;
{
RWLockWRGuard _(m_rw_lock);
if (index >= m_cache.size())
return {};
auto& cache = m_cache[index];
if (cache.dirty_mask == 0)
return {};
PageTable::with_fast_page(cache.paddr, [&] {
memcpy(m_sync_cache.data(), PageTable::fast_page_as_ptr(), PAGE_SIZE);
});
temp_cache = cache;
cache.dirty_mask = 0;
cache.syncing = true;
}
// restores dirty mask if write to disk fails
BAN::ScopeGuard dirty_guard([&] {
RWLockWRGuard _(m_rw_lock);
const auto new_index = find_sector_cache_index(temp_cache.first_sector);
ASSERT(new_index < m_cache.size() && m_cache[new_index].first_sector == temp_cache.first_sector);
m_cache[new_index].dirty_mask |= temp_cache.dirty_mask;
m_cache[new_index].syncing = false;
});
uint8_t sector_start = 0;
@@ -128,15 +156,16 @@ namespace Kernel
while (sector_start + sector_count <= PAGE_SIZE / m_sector_size)
{
if (cache.dirty_mask & (1 << (sector_start + sector_count)))
if (temp_cache.dirty_mask & (1 << (sector_start + sector_count)))
sector_count++;
else if (sector_count == 0)
sector_start++;
else
{
dprintln_if(DEBUG_DISK_SYNC, "syncing {}->{}", cache.first_sector + sector_start, cache.first_sector + sector_start + sector_count);
dprintln_if(DEBUG_DISK_SYNC, "syncing {}->{}", temp_cache.first_sector + sector_start, temp_cache.first_sector + sector_start + sector_count);
auto data_slice = m_sync_cache.span().slice(sector_start * m_sector_size, sector_count * m_sector_size);
TRY(m_device.write_sectors_impl(cache.first_sector + sector_start, sector_count, data_slice));
TRY(m_device.write_sectors_impl(temp_cache.first_sector + sector_start, sector_count, data_slice));
temp_cache.dirty_mask &= ~(((1 << sector_count) - 1) << sector_start);
sector_start += sector_count + 1;
sector_count = 0;
}
@@ -144,13 +173,12 @@ namespace Kernel
if (sector_count > 0)
{
dprintln_if(DEBUG_DISK_SYNC, "syncing {}->{}", cache.first_sector + sector_start, cache.first_sector + sector_start + sector_count);
dprintln_if(DEBUG_DISK_SYNC, "syncing {}->{}", temp_cache.first_sector + sector_start, temp_cache.first_sector + sector_start + sector_count);
auto data_slice = m_sync_cache.span().slice(sector_start * m_sector_size, sector_count * m_sector_size);
TRY(m_device.write_sectors_impl(cache.first_sector + sector_start, sector_count, data_slice));
TRY(m_device.write_sectors_impl(temp_cache.first_sector + sector_start, sector_count, data_slice));
temp_cache.dirty_mask &= ~(((1 << sector_count) - 1) << sector_start);
}
cache.dirty_mask = 0;
return {};
}
@@ -168,17 +196,17 @@ namespace Kernel
if (g_disable_disk_write)
return {};
const uint64_t sectors_per_page = PAGE_SIZE / m_sector_size;
const uint64_t page_cache_offset = sector % sectors_per_page;
const uint64_t page_cache_start = sector - page_cache_offset;
m_rw_lock.rd_lock();
for (size_t i = find_sector_cache_index(sector); i < m_cache.size(); i++)
{
auto& cache = m_cache[i];
if (cache.first_sector * sectors_per_page >= page_cache_start * sectors_per_page + block_count)
if (cache.first_sector >= sector + block_count)
break;
m_rw_lock.rd_unlock();
TRY(sync_cache_index(i));
m_rw_lock.rd_lock();
}
m_rw_lock.rd_unlock();
return {};
}
@@ -188,10 +216,12 @@ namespace Kernel
// NOTE: There might not actually be page_count pages after this
// function returns. The synchronization must be done elsewhere.
RWLockWRGuard _(m_rw_lock);
size_t released = 0;
for (size_t i = 0; i < m_cache.size() && released < page_count;)
{
if (m_cache[i].dirty_mask == 0)
if (!m_cache[i].syncing && m_cache[i].dirty_mask == 0)
{
Heap::get().release_page(m_cache[i].paddr);
m_cache.remove(i);

7
kernel/kernel/Storage/StorageDevice.cpp
View File

@@ -211,14 +211,12 @@ namespace Kernel
void StorageDevice::add_disk_cache()
{
LockGuard _(m_mutex);
ASSERT(!m_disk_cache.has_value());
m_disk_cache.emplace(sector_size(), *this);
}
size_t StorageDevice::drop_disk_cache()
{
LockGuard _(m_mutex);
if (m_disk_cache.has_value())
return m_disk_cache->release_pages(-1);
return 0;
@@ -226,7 +224,6 @@ namespace Kernel
BAN::ErrorOr<void> StorageDevice::sync_disk_cache()
{
LockGuard _(m_mutex);
if (m_disk_cache.has_value())
TRY(m_disk_cache->sync());
return {};
@@ -236,8 +233,6 @@ namespace Kernel
{
ASSERT(buffer.size() >= sector_count * sector_size());
LockGuard _(m_mutex);
if (!m_disk_cache.has_value())
return read_sectors_impl(lba, sector_count, buffer);
@@ -275,8 +270,6 @@ namespace Kernel
{
ASSERT(buffer.size() >= sector_count * sector_size());
LockGuard _(m_mutex);
if (g_disable_disk_write)
{
if (!m_disk_cache.has_value())