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

Kernel: Rewrite all read/write functions to use BAN::ByteSpan

Browse Source 
This allows us to not work with raw pointers and use sized containers
for reading and writing.
This commit is contained in:
Bananymous
2023-10-20 05:07:44 +03:00
parent 71cad2fc38
commit f3d9da9549
36 changed files with 216 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
kernel/kernel/FS/Ext2/FileSystem.cpp
View File

@@ -33,7 +33,7 @@ namespace Kernel
BAN::Vector<uint8_t> superblock_buffer;
TRY(superblock_buffer.resize(sector_count * sector_size));
TRY(m_partition.read_sectors(lba, sector_count, superblock_buffer.data()));
TRY(m_partition.read_sectors(lba, sector_count, superblock_buffer.span()));
memcpy(&m_superblock, superblock_buffer.data(), sizeof(Ext2::Superblock));
}
@@ -223,7 +223,7 @@ namespace Kernel
ASSERT(block >= 2);
ASSERT(buffer.size() >= block_size);
MUST(m_partition.read_sectors(sectors_before + (block - 2) * sectors_per_block, sectors_per_block, buffer.data()));
MUST(m_partition.read_sectors(sectors_before + (block - 2) * sectors_per_block, sectors_per_block, buffer.span()));
}
void Ext2FS::write_block(uint32_t block, const BlockBufferWrapper& buffer)
@@ -237,7 +237,7 @@ namespace Kernel
ASSERT(block >= 2);
ASSERT(buffer.size() >= block_size);
MUST(m_partition.write_sectors(sectors_before + (block - 2) * sectors_per_block, sectors_per_block, buffer.data()));
MUST(m_partition.write_sectors(sectors_before + (block - 2) * sectors_per_block, sectors_per_block, buffer.span()));
}
void Ext2FS::sync_superblock()
@@ -258,11 +258,11 @@ namespace Kernel
BAN::Vector<uint8_t> superblock_buffer;
MUST(superblock_buffer.resize(sector_count * sector_size));
MUST(m_partition.read_sectors(lba, sector_count, superblock_buffer.data()));
MUST(m_partition.read_sectors(lba, sector_count, superblock_buffer.span()));
if (memcmp(superblock_buffer.data(), &m_superblock, superblock_bytes))
{
memcpy(superblock_buffer.data(), &m_superblock, superblock_bytes);
MUST(m_partition.write_sectors(lba, sector_count, superblock_buffer.data()));
MUST(m_partition.write_sectors(lba, sector_count, superblock_buffer.span()));
}
}

35
kernel/kernel/FS/Ext2/Inode.cpp
View File

@@ -100,19 +100,21 @@ namespace Kernel
return BAN::Error::from_errno(ENOTSUP);
}
BAN::ErrorOr<size_t> Ext2Inode::read_impl(off_t offset, void* buffer, size_t count)
BAN::ErrorOr<size_t> Ext2Inode::read_impl(off_t offset, BAN::ByteSpan buffer)
{
// FIXME: update atime if needed
ASSERT(!mode().ifdir());
ASSERT(offset >= 0);
if (offset >= UINT32_MAX || count >= UINT32_MAX || offset + count >= UINT32_MAX)
if (offset >= UINT32_MAX || buffer.size() >= UINT32_MAX || buffer.size() >= (size_t)(UINT32_MAX - offset))
return BAN::Error::from_errno(EOVERFLOW);
if (offset >= m_inode.size)
return 0;
if (offset + count > m_inode.size)
uint32_t count = buffer.size();
if (offset + buffer.size() > m_inode.size)
count = m_inode.size - offset;
const uint32_t block_size = blksize();
@@ -131,7 +133,7 @@ namespace Kernel
uint32_t copy_offset = (offset + n_read) % block_size;
uint32_t to_copy = BAN::Math::min<uint32_t>(block_size - copy_offset, count - n_read);
memcpy((uint8_t*)buffer + n_read, block_buffer.data() + copy_offset, to_copy);
memcpy(buffer.data() + n_read, block_buffer.data() + copy_offset, to_copy);
n_read += to_copy;
}
@@ -139,26 +141,25 @@ namespace Kernel
return n_read;
}
BAN::ErrorOr<size_t> Ext2Inode::write_impl(off_t offset, const void* buffer, size_t count)
BAN::ErrorOr<size_t> Ext2Inode::write_impl(off_t offset, BAN::ConstByteSpan buffer)
{
// FIXME: update atime if needed
ASSERT(!mode().ifdir());
ASSERT(offset >= 0);
if (offset >= UINT32_MAX || count >= UINT32_MAX || offset + count >= UINT32_MAX)
if (offset >= UINT32_MAX || buffer.size() >= UINT32_MAX || buffer.size() >= (size_t)(UINT32_MAX - offset))
return BAN::Error::from_errno(EOVERFLOW);
if (m_inode.size < offset + count)
TRY(truncate_impl(offset + count));
if (m_inode.size < offset + buffer.size())
TRY(truncate_impl(offset + buffer.size()));
const uint32_t block_size = blksize();
auto block_buffer = m_fs.get_block_buffer();
const uint8_t* u8buffer = (const uint8_t*)buffer;
size_t to_write = count;
size_t written = 0;
size_t to_write = buffer.size();
// Write partial block
if (offset % block_size)
@@ -169,10 +170,10 @@ namespace Kernel
uint32_t to_copy = BAN::Math::min<uint32_t>(block_size - block_offset, to_write);
m_fs.read_block(block_index, block_buffer);
memcpy(block_buffer.data() + block_offset, u8buffer, to_copy);
memcpy(block_buffer.data() + block_offset, buffer.data(), to_copy);
m_fs.write_block(block_index, block_buffer);
u8buffer += to_copy;
written += to_copy;
offset += to_copy;
to_write -= to_copy;
}
@@ -181,10 +182,10 @@ namespace Kernel
{
uint32_t block_index = fs_block_of_data_block_index(offset / block_size);
memcpy(block_buffer.data(), u8buffer, block_buffer.size());
memcpy(block_buffer.data(), buffer.data() + written, block_buffer.size());
m_fs.write_block(block_index, block_buffer);
u8buffer += block_size;
written += block_size;
offset += block_size;
to_write -= block_size;
}
@@ -194,11 +195,11 @@ namespace Kernel
uint32_t block_index = fs_block_of_data_block_index(offset / block_size);
m_fs.read_block(block_index, block_buffer);
memcpy(block_buffer.data(), u8buffer, to_write);
memcpy(block_buffer.data(), buffer.data() + written, to_write);
m_fs.write_block(block_index, block_buffer);
}
return count;
return buffer.size();
}
BAN::ErrorOr<void> Ext2Inode::truncate_impl(size_t new_size)

8
kernel/kernel/FS/Inode.cpp
View File

@@ -102,22 +102,22 @@ namespace Kernel
return link_target_impl();
}
BAN::ErrorOr<size_t> Inode::read(off_t offset, void* buffer, size_t bytes)
BAN::ErrorOr<size_t> Inode::read(off_t offset, BAN::ByteSpan buffer)
{
LockGuard _(m_lock);
Thread::TerminateBlocker blocker(Thread::current());
if (mode().ifdir())
return BAN::Error::from_errno(EISDIR);
return read_impl(offset, buffer, bytes);
return read_impl(offset, buffer);
}
BAN::ErrorOr<size_t> Inode::write(off_t offset, const void* buffer, size_t bytes)
BAN::ErrorOr<size_t> Inode::write(off_t offset, BAN::ConstByteSpan buffer)
{
LockGuard _(m_lock);
Thread::TerminateBlocker blocker(Thread::current());
if (mode().ifdir())
return BAN::Error::from_errno(EISDIR);
return write_impl(offset, buffer, bytes);
return write_impl(offset, buffer);
}
BAN::ErrorOr<void> Inode::truncate(size_t size)

14
kernel/kernel/FS/Pipe.cpp
View File

@@ -39,7 +39,7 @@ namespace Kernel
m_semaphore.unblock();
}
BAN::ErrorOr<size_t> Pipe::read_impl(off_t, void* buffer, size_t count)
BAN::ErrorOr<size_t> Pipe::read_impl(off_t, BAN::ByteSpan buffer)
{
LockGuard _(m_lock);
while (m_buffer.empty())
@@ -51,8 +51,8 @@ namespace Kernel
m_lock.lock();
}
size_t to_copy = BAN::Math::min<size_t>(count, m_buffer.size());
memcpy(buffer, m_buffer.data(), to_copy);
size_t to_copy = BAN::Math::min<size_t>(buffer.size(), m_buffer.size());
memcpy(buffer.data(), m_buffer.data(), to_copy);
memmove(m_buffer.data(), m_buffer.data() + to_copy, m_buffer.size() - to_copy);
MUST(m_buffer.resize(m_buffer.size() - to_copy));
@@ -64,14 +64,14 @@ namespace Kernel
return to_copy;
}
BAN::ErrorOr<size_t> Pipe::write_impl(off_t, const void* buffer, size_t count)
BAN::ErrorOr<size_t> Pipe::write_impl(off_t, BAN::ConstByteSpan buffer)
{
LockGuard _(m_lock);
size_t old_size = m_buffer.size();
TRY(m_buffer.resize(old_size + count));
memcpy(m_buffer.data() + old_size, buffer, count);
TRY(m_buffer.resize(old_size + buffer.size()));
memcpy(m_buffer.data() + old_size, buffer.data(), buffer.size());
timespec current_time = SystemTimer::get().real_time();
m_mtime = current_time;
@@ -79,7 +79,7 @@ namespace Kernel
m_semaphore.unblock();
return count;
return buffer.size();
}
}

8
kernel/kernel/FS/ProcFS/Inode.cpp
View File

@@ -25,7 +25,7 @@ namespace Kernel
{
}
BAN::ErrorOr<BAN::RefPtr<ProcROInode>> ProcROInode::create(Process& process, size_t (Process::*callback)(off_t, void*, size_t) const, RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
BAN::ErrorOr<BAN::RefPtr<ProcROInode>> ProcROInode::create(Process& process, size_t (Process::*callback)(off_t, BAN::ByteSpan) const, RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
{
FullInodeInfo inode_info(fs, mode, uid, gid);
@@ -35,7 +35,7 @@ namespace Kernel
return BAN::RefPtr<ProcROInode>::adopt(inode_ptr);
}
ProcROInode::ProcROInode(Process& process, size_t (Process::*callback)(off_t, void*, size_t) const, RamFileSystem& fs, const FullInodeInfo& inode_info)
ProcROInode::ProcROInode(Process& process, size_t (Process::*callback)(off_t, BAN::ByteSpan) const, RamFileSystem& fs, const FullInodeInfo& inode_info)
: RamInode(fs, inode_info)
, m_process(process)
, m_callback(callback)
@@ -43,12 +43,12 @@ namespace Kernel
m_inode_info.mode |= Inode::Mode::IFREG;
}
BAN::ErrorOr<size_t> ProcROInode::read_impl(off_t offset, void* buffer, size_t buffer_size)
BAN::ErrorOr<size_t> ProcROInode::read_impl(off_t offset, BAN::ByteSpan buffer)
{
ASSERT(offset >= 0);
if ((size_t)offset >= sizeof(proc_meminfo_t))
return 0;
return (m_process.*m_callback)(offset, buffer, buffer_size);
return (m_process.*m_callback)(offset, buffer);
}
}

16
kernel/kernel/FS/RamFS/Inode.cpp
View File

@@ -48,23 +48,23 @@ namespace Kernel
m_inode_info.mode |= Inode::Mode::IFREG;
}
BAN::ErrorOr<size_t> RamFileInode::read_impl(off_t offset, void* buffer, size_t bytes)
BAN::ErrorOr<size_t> RamFileInode::read_impl(off_t offset, BAN::ByteSpan buffer)
{
ASSERT(offset >= 0);
if (offset >= size())
return 0;
size_t to_copy = BAN::Math::min<size_t>(m_inode_info.size - offset, bytes);
memcpy(buffer, m_data.data(), to_copy);
size_t to_copy = BAN::Math::min<size_t>(m_inode_info.size - offset, buffer.size());
memcpy(buffer.data(), m_data.data(), to_copy);
return to_copy;
}
BAN::ErrorOr<size_t> RamFileInode::write_impl(off_t offset, const void* buffer, size_t bytes)
BAN::ErrorOr<size_t> RamFileInode::write_impl(off_t offset, BAN::ConstByteSpan buffer)
{
ASSERT(offset >= 0);
if (offset + bytes > (size_t)size())
TRY(truncate_impl(offset + bytes));
memcpy(m_data.data() + offset, buffer, bytes);
return bytes;
if (offset + buffer.size() > (size_t)size())
TRY(truncate_impl(offset + buffer.size()));
memcpy(m_data.data() + offset, buffer.data(), buffer.size());
return buffer.size();
}
BAN::ErrorOr<void> RamFileInode::truncate_impl(size_t new_size)