RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-30 18:28:10 +00:00
Code Issues Activity Actions

Kernel: Remove various other uses of ssize_t

Browse source
This commit is contained in:
Gunnar Beutner 2021-06-16 16:44:15 +02:00 • committed by Andreas Kling
parent ca3cae81eb
commit bc3076f894
33 changed files with 123 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Devices/HID/KeyboardDevice.cpp
View file

@ -289,7 +289,7 @@ KResultOr<size_t> KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer
if (m_queue.is_empty())
break;
// Don't return partial data frames.
if ((size - nread) < (ssize_t)sizeof(Event))
if (size - nread < sizeof(Event))
break;
auto event = m_queue.dequeue();

12
Kernel/FileSystem/DevFS.cpp
View file

@ -81,7 +81,7 @@ DevFSInode::DevFSInode(DevFS& fs)
{
}
KResultOr<ssize_t> DevFSInode::read_bytes(off_t, ssize_t, UserOrKernelBuffer&, FileDescription*) const
KResultOr<size_t> DevFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
{
VERIFY_NOT_REACHED();
}
@ -100,7 +100,7 @@ void DevFSInode::flush_metadata()
{
}
KResultOr<ssize_t> DevFSInode::write_bytes(off_t, ssize_t, const UserOrKernelBuffer&, FileDescription*)
KResultOr<size_t> DevFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
{
VERIFY_NOT_REACHED();
}
@ -152,7 +152,7 @@ DevFSLinkInode::DevFSLinkInode(DevFS& fs, String name)
, m_name(name)
{
}
KResultOr<ssize_t> DevFSLinkInode::read_bytes(off_t offset, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const
KResultOr<size_t> DevFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, FileDescription*) const
{
Locker locker(m_lock);
VERIFY(offset == 0);
@ -173,7 +173,7 @@ InodeMetadata DevFSLinkInode::metadata() const
metadata.mtime = mepoch;
return metadata;
}
KResultOr<ssize_t> DevFSLinkInode::write_bytes(off_t offset, ssize_t count, const UserOrKernelBuffer& buffer, FileDescription*)
KResultOr<size_t> DevFSLinkInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, FileDescription*)
{
Locker locker(m_lock);
VERIFY(offset == 0);
@ -350,7 +350,7 @@ String DevFSDeviceInode::name() const
return m_cached_name;
}
KResultOr<ssize_t> DevFSDeviceInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
KResultOr<size_t> DevFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
{
Locker locker(m_lock);
VERIFY(!!description);
@ -376,7 +376,7 @@ InodeMetadata DevFSDeviceInode::metadata() const
metadata.minor_device = m_attached_device->minor();
return metadata;
}
KResultOr<ssize_t> DevFSDeviceInode::write_bytes(off_t offset, ssize_t count, const UserOrKernelBuffer& buffer, FileDescription* description)
KResultOr<size_t> DevFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, FileDescription* description)
{
Locker locker(m_lock);
VERIFY(!!description);

12
Kernel/FileSystem/DevFS.h
View file

@ -57,11 +57,11 @@ public:
protected:
DevFSInode(DevFS&);
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;
@ -83,9 +83,9 @@ private:
String determine_name() const;
DevFSDeviceInode(DevFS&, const Device&);
// ^Inode
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResult chown(uid_t, gid_t) override;
NonnullRefPtr<Device> m_attached_device;
@ -106,9 +106,9 @@ public:
protected:
DevFSLinkInode(DevFS&, String);
// ^Inode
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
const String m_name;
String m_link;

4
Kernel/FileSystem/DevPtsFS.cpp
View file

@ -100,12 +100,12 @@ DevPtsFSInode::~DevPtsFSInode()
{
}
KResultOr<ssize_t> DevPtsFSInode::read_bytes(off_t, ssize_t, UserOrKernelBuffer&, FileDescription*) const
KResultOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
{
VERIFY_NOT_REACHED();
}
KResultOr<ssize_t> DevPtsFSInode::write_bytes(off_t, ssize_t, const UserOrKernelBuffer&, FileDescription*)
KResultOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
{
VERIFY_NOT_REACHED();
}

4
Kernel/FileSystem/DevPtsFS.h
View file

@ -47,12 +47,12 @@ private:
DevPtsFSInode(DevPtsFS&, InodeIndex, SlavePTY*);
// ^Inode
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;

13
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -21,7 +21,7 @@
namespace Kernel {
static constexpr size_t max_block_size = 4096;
static constexpr ssize_t max_inline_symlink_length = 60;
static constexpr size_t max_inline_symlink_length = 60;
struct Ext2FSDirectoryEntry {
String name;
@ -823,7 +823,7 @@ RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
return new_inode;
}
KResultOr<ssize_t> Ext2FSInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
{
Locker inode_locker(m_lock);
VERIFY(offset >= 0);
@ -837,7 +837,7 @@ KResultOr<ssize_t> Ext2FSInode::read_bytes(off_t offset, ssize_t count, UserOrKe
// This avoids wasting an entire block on short links. (Most links are short.)
if (is_symlink() && size() < max_inline_symlink_length) {
VERIFY(offset == 0);
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
size_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
if (!buffer.write(((const u8*)m_raw_inode.i_block) + offset, (size_t)nread))
return EFAULT;
return nread;
@ -862,7 +862,7 @@ KResultOr<ssize_t> Ext2FSInode::read_bytes(off_t offset, ssize_t count, UserOrKe
int offset_into_first_block = offset % block_size;
ssize_t nread = 0;
size_t nread = 0;
auto remaining_count = min((off_t)count, (off_t)size() - offset);
dbgln_if(EXT2_VERY_DEBUG, "Ext2FSInode[{}]::read_bytes(): Reading up to {} bytes, {} bytes into inode to {}", identifier(), count, offset, buffer.user_or_kernel_ptr());
@ -968,10 +968,9 @@ KResult Ext2FSInode::resize(u64 new_size)
return KSuccess;
}
KResultOr<ssize_t> Ext2FSInode::write_bytes(off_t offset, ssize_t count, const UserOrKernelBuffer& data, FileDescription* description)
KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, FileDescription* description)
{
VERIFY(offset >= 0);
VERIFY(count >= 0);
if (count == 0)
return 0;
@ -1017,7 +1016,7 @@ KResultOr<ssize_t> Ext2FSInode::write_bytes(off_t offset, ssize_t count, const U
size_t offset_into_first_block = offset % block_size;
ssize_t nwritten = 0;
size_t nwritten = 0;
auto remaining_count = min((off_t)count, (off_t)new_size - offset);
dbgln_if(EXT2_VERY_DEBUG, "Ext2FSInode[{}]::write_bytes(): Writing {} bytes, {} bytes into inode from {}", identifier(), count, offset, data.user_or_kernel_ptr());

4
Kernel/FileSystem/Ext2FileSystem.h
View file

@ -38,12 +38,12 @@ public:
private:
// ^Inode
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& data, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode& child, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;

5
Kernel/FileSystem/FileDescription.cpp
View file

@ -203,7 +203,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> FileDescription::read_entire_file()
return m_inode->read_entire(this);
}
KResultOr<ssize_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, ssize_t size)
KResultOr<size_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, size_t size)
{
Locker locker(m_lock, Lock::Mode::Shared);
if (!is_directory())
@ -213,9 +213,6 @@ KResultOr<ssize_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_b
if (!metadata.is_valid())
return EIO;
if (size < 0)
return EINVAL;
size_t remaining = size;
KResult error = KSuccess;
u8 stack_buffer[PAGE_SIZE];

2
Kernel/FileSystem/FileDescription.h
View file

@ -56,7 +56,7 @@ public:
bool can_read() const;
bool can_write() const;
KResultOr<ssize_t> get_dir_entries(UserOrKernelBuffer& buffer, ssize_t);
KResultOr<size_t> get_dir_entries(UserOrKernelBuffer& buffer, size_t);
KResultOr<NonnullOwnPtr<KBuffer>> read_entire_file();

10
Kernel/FileSystem/Inode.cpp
View file

@ -51,7 +51,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(FileDescription* descriptio
{
KBufferBuilder builder;
ssize_t nread;
size_t nread;
u8 buffer[4096];
off_t offset = 0;
for (;;) {
@ -60,18 +60,14 @@ KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(FileDescription* descriptio
if (result.is_error())
return result.error();
nread = result.value();
VERIFY(nread <= (ssize_t)sizeof(buffer));
VERIFY(nread <= sizeof(buffer));
if (nread <= 0)
break;
builder.append((const char*)buffer, nread);
offset += nread;
if (nread < (ssize_t)sizeof(buffer))
if (nread < sizeof(buffer))
break;
}
if (nread < 0) {
dmesgln("Inode::read_entire: Error: {}", nread);
return KResult((ErrnoCode)-nread);
}
auto entire_file = builder.build();
if (!entire_file)

4
Kernel/FileSystem/Inode.h
View file

@ -52,10 +52,10 @@ public:
virtual KResult attach(FileDescription&) { return KSuccess; }
virtual void detach(FileDescription&) { }
virtual void did_seek(FileDescription&, off_t) { }
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const = 0;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const = 0;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const = 0;
virtual RefPtr<Inode> lookup(StringView name) = 0;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& data, FileDescription*) = 0;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) = 0;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) = 0;
virtual KResult add_child(Inode&, const StringView& name, mode_t) = 0;
virtual KResult remove_child(const StringView& name) = 0;

10
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -171,7 +171,7 @@ public:
const KBuffer& build();
static constexpr ssize_t max_header_size = 24;
static constexpr size_t max_header_size = 24;
private:
template<typename N>
@ -634,9 +634,9 @@ KResult Plan9FS::post_message_and_wait_for_a_reply(Message& message)
}
}
ssize_t Plan9FS::adjust_buffer_size(ssize_t size) const
size_t Plan9FS::adjust_buffer_size(size_t size) const
{
ssize_t max_size = m_max_message_size - Message::max_header_size;
size_t max_size = m_max_message_size - Message::max_header_size;
return min(size, max_size);
}
@ -728,7 +728,7 @@ KResult Plan9FSInode::ensure_open_for_mode(int mode)
}
}
KResultOr<ssize_t> Plan9FSInode::read_bytes(off_t offset, ssize_t size, UserOrKernelBuffer& buffer, FileDescription*) const
KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, FileDescription*) const
{
auto result = const_cast<Plan9FSInode&>(*this).ensure_open_for_mode(O_RDONLY);
if (result.is_error())
@ -767,7 +767,7 @@ KResultOr<ssize_t> Plan9FSInode::read_bytes(off_t offset, ssize_t size, UserOrKe
return nread;
}
KResultOr<ssize_t> Plan9FSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelBuffer& data, FileDescription*)
KResultOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, FileDescription*)
{
auto result = ensure_open_for_mode(O_WRONLY);
if (result.is_error())

6
Kernel/FileSystem/Plan9FileSystem.h
View file

@ -123,7 +123,7 @@ private:
KResult post_message_and_explicitly_ignore_reply(Message&);
ProtocolVersion parse_protocol_version(const StringView&) const;
ssize_t adjust_buffer_size(ssize_t size) const;
size_t adjust_buffer_size(size_t size) const;
void thread_main();
void ensure_thread();
@ -156,8 +156,8 @@ public:
// ^Inode
virtual InodeMetadata metadata() const override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& data, FileDescription*) override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;

28
Kernel/FileSystem/ProcFS.cpp
View file

@ -895,7 +895,7 @@ static bool read_sys_bool(InodeIdentifier inode_id, KBufferBuilder& builder)
return true;
}
static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer& buffer, size_t size)
static KResultOr<size_t> write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer& buffer, size_t size)
{
auto& variable = SysVariable::for_inode(inode_id);
VERIFY(variable.type == SysVariable::Type::Boolean);
@ -913,7 +913,7 @@ static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer
return result.error();
VERIFY(result.value() == 0 || (result.value() == 1 && did_read));
if (result.value() == 0 || !(value == '0' || value == '1'))
return (ssize_t)size;
return size;
auto* lockable_bool = reinterpret_cast<Lockable<bool>*>(variable.address);
{
@ -921,7 +921,7 @@ static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer
lockable_bool->resource() = value == '1';
}
variable.notify();
return (ssize_t)size;
return size;
}
static bool read_sys_string(InodeIdentifier inode_id, KBufferBuilder& builder)
@ -935,14 +935,14 @@ static bool read_sys_string(InodeIdentifier inode_id, KBufferBuilder& builder)
return true;
}
static ssize_t write_sys_string(InodeIdentifier inode_id, const UserOrKernelBuffer& buffer, size_t size)
static KResultOr<size_t> write_sys_string(InodeIdentifier inode_id, const UserOrKernelBuffer& buffer, size_t size)
{
auto& variable = SysVariable::for_inode(inode_id);
VERIFY(variable.type == SysVariable::Type::String);
auto string_copy = buffer.copy_into_string(size);
if (string_copy.is_null())
return -EFAULT;
return EFAULT;
{
auto* lockable_string = reinterpret_cast<Lockable<String>*>(variable.address);
@ -950,7 +950,7 @@ static ssize_t write_sys_string(InodeIdentifier inode_id, const UserOrKernelBuff
lockable_string->resource() = move(string_copy);
}
variable.notify();
return (ssize_t)size;
return size;
}
void ProcFS::add_sys_bool(String&& name, Lockable<bool>& var, Function<void()>&& notify_callback)
@ -1223,7 +1223,7 @@ InodeMetadata ProcFSInode::metadata() const
return metadata;
}
KResultOr<ssize_t> ProcFSInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
KResultOr<size_t> ProcFSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
{
dbgln_if(PROCFS_DEBUG, "ProcFS: read_bytes offset: {} count: {}", offset, count);
VERIFY(offset >= 0);
@ -1242,7 +1242,7 @@ KResultOr<ssize_t> ProcFSInode::read_bytes(off_t offset, ssize_t count, UserOrKe
if (!data_buffer || (size_t)offset >= data_buffer->size())
return 0;
ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
size_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
if (!buffer.write(data_buffer->data() + offset, nread))
return EFAULT;
@ -1454,7 +1454,7 @@ void ProcFSInode::flush_metadata()
{
}
KResultOr<ssize_t> ProcFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelBuffer& buffer, FileDescription*)
KResultOr<size_t> ProcFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, FileDescription*)
{
// For process-specific inodes, hold the process's ptrace lock across the write
// and refuse to write at all data if the process is not dumpable.
@ -1478,7 +1478,7 @@ KResultOr<ssize_t> ProcFSInode::write_bytes(off_t offset, ssize_t size, const Us
auto* directory_entry = fs().get_directory_entry(identifier());
ssize_t (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr;
KResultOr<size_t> (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr;
if (directory_entry == nullptr) {
if (to_proc_parent_directory(identifier()) == PDI_Root_sys) {
@ -1503,10 +1503,10 @@ KResultOr<ssize_t> ProcFSInode::write_bytes(off_t offset, ssize_t size, const Us
VERIFY(is_persistent_inode(identifier()));
// FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support..
VERIFY(offset == 0);
ssize_t nwritten = write_callback(identifier(), buffer, (size_t)size);
if (nwritten < 0)
dbgln("ProcFS: Writing {} bytes failed: {}", size, nwritten);
return nwritten;
auto nwritten_or_error = write_callback(identifier(), buffer, (size_t)size);
if (nwritten_or_error.is_error())
dbgln("ProcFS: Writing {} bytes failed: {}", size, nwritten_or_error.error());
return nwritten_or_error;
}
KResultOr<NonnullRefPtr<Custody>> ProcFSInode::resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const

12
Kernel/FileSystem/ProcFS.h
View file

@ -38,7 +38,7 @@ private:
struct ProcFSDirectoryEntry {
ProcFSDirectoryEntry() = default;
ProcFSDirectoryEntry(const char* a_name, unsigned a_proc_file_type, bool a_supervisor_only, bool (*read_callback)(InodeIdentifier, KBufferBuilder&) = nullptr, ssize_t (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr, RefPtr<ProcFSInode>&& a_inode = nullptr)
ProcFSDirectoryEntry(const char* a_name, unsigned a_proc_file_type, bool a_supervisor_only, bool (*read_callback)(InodeIdentifier, KBufferBuilder&) = nullptr, KResultOr<size_t> (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t) = nullptr, RefPtr<ProcFSInode>&& a_inode = nullptr)
: name(a_name)
, proc_file_type(a_proc_file_type)
, supervisor_only(a_supervisor_only)
@ -52,7 +52,7 @@ private:
unsigned proc_file_type { 0 };
bool supervisor_only { false };
bool (*read_callback)(InodeIdentifier, KBufferBuilder&);
ssize_t (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t);
KResultOr<size_t> (*write_callback)(InodeIdentifier, const UserOrKernelBuffer&, size_t);
RefPtr<ProcFSInode> inode;
InodeIdentifier identifier(unsigned fsid) const;
};
@ -77,12 +77,12 @@ private:
// ^Inode
virtual KResult attach(FileDescription&) override;
virtual void did_seek(FileDescription&, off_t) override;
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;
@ -111,12 +111,12 @@ private:
// ^Inode
virtual KResult attach(FileDescription&) override;
virtual void did_seek(FileDescription&, off_t) override;
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer&, FileDescription*) const override { VERIFY_NOT_REACHED(); }
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const override { VERIFY_NOT_REACHED(); }
virtual InodeMetadata metadata() const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override { VERIFY_NOT_REACHED(); }
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override {};
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer&, FileDescription*) override { VERIFY_NOT_REACHED(); }
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*) override { VERIFY_NOT_REACHED(); }
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;

5
Kernel/FileSystem/TmpFS.cpp
View file

@ -127,11 +127,10 @@ KResult TmpFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry
return KSuccess;
}
KResultOr<ssize_t> TmpFSInode::read_bytes(off_t offset, ssize_t size, UserOrKernelBuffer& buffer, FileDescription*) const
KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, FileDescription*) const
{
Locker locker(m_lock, Lock::Mode::Shared);
VERIFY(!is_directory());
VERIFY(size >= 0);
VERIFY(offset >= 0);
if (!m_content)
@ -148,7 +147,7 @@ KResultOr<ssize_t> TmpFSInode::read_bytes(off_t offset, ssize_t size, UserOrKern
return size;
}
KResultOr<ssize_t> TmpFSInode::write_bytes(off_t offset, ssize_t size, const UserOrKernelBuffer& buffer, FileDescription*)
KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, FileDescription*)
{
Locker locker(m_lock);
VERIFY(!is_directory());

4
Kernel/FileSystem/TmpFS.h
View file

@ -54,12 +54,12 @@ public:
const TmpFS& fs() const { return static_cast<const TmpFS&>(Inode::fs()); }
// ^Inode
virtual KResultOr<ssize_t> read_bytes(off_t, ssize_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual KResult traverse_as_directory(Function<bool(const FS::DirectoryEntryView&)>) const override;
virtual RefPtr<Inode> lookup(StringView name) override;
virtual void flush_metadata() override;
virtual KResultOr<ssize_t> write_bytes(off_t, ssize_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
virtual KResultOr<NonnullRefPtr<Inode>> create_child(const String& name, mode_t, dev_t, uid_t, gid_t) override;
virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;

2
Kernel/Heap/SlabAllocator.cpp
View file

@ -97,7 +97,7 @@ private:
};
Atomic<FreeSlab*> m_freelist { nullptr };
Atomic<ssize_t, AK::MemoryOrder::memory_order_relaxed> m_num_allocated;
Atomic<size_t, AK::MemoryOrder::memory_order_relaxed> m_num_allocated;
size_t m_slab_count;
void* m_base { nullptr };
void* m_end { nullptr };

26
Kernel/Process.h
View file

@ -270,7 +270,7 @@ public:
KResultOr<int> sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params);
KResultOr<int> sys$inode_watcher_remove_watch(int fd, int wd);
KResultOr<int> sys$dbgputch(u8);
KResultOr<size_t> sys$dbgputstr(Userspace<const u8*>, int length);
KResultOr<size_t> sys$dbgputstr(Userspace<const u8*>, size_t);
KResultOr<int> sys$dump_backtrace();
KResultOr<pid_t> sys$gettid();
KResultOr<int> sys$donate(pid_t tid);
@ -290,10 +290,10 @@ public:
KResultOr<mode_t> sys$umask(mode_t);
KResultOr<int> sys$open(Userspace<const Syscall::SC_open_params*>);
KResultOr<int> sys$close(int fd);
KResultOr<ssize_t> sys$read(int fd, Userspace<u8*>, ssize_t);
KResultOr<ssize_t> sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count);
KResultOr<ssize_t> sys$write(int fd, Userspace<const u8*>, ssize_t);
KResultOr<ssize_t> sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count);
KResultOr<size_t> sys$read(int fd, Userspace<u8*>, size_t);
KResultOr<size_t> sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count);
KResultOr<size_t> sys$write(int fd, Userspace<const u8*>, size_t);
KResultOr<size_t> sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count);
KResultOr<int> sys$fstat(int fd, Userspace<stat*>);
KResultOr<int> sys$stat(Userspace<const Syscall::SC_stat_params*>);
KResultOr<int> sys$lseek(int fd, Userspace<off_t*>, int whence);
@ -312,7 +312,7 @@ public:
KResultOr<int> sys$purge(int mode);
KResultOr<int> sys$select(Userspace<const Syscall::SC_select_params*>);
KResultOr<int> sys$poll(Userspace<const Syscall::SC_poll_params*>);
KResultOr<ssize_t> sys$get_dir_entries(int fd, Userspace<void*>, ssize_t);
KResultOr<size_t> sys$get_dir_entries(int fd, Userspace<void*>, size_t);
KResultOr<int> sys$getcwd(Userspace<char*>, size_t);
KResultOr<int> sys$chdir(Userspace<const char*>, size_t);
KResultOr<int> sys$fchdir(int fd);
@ -321,8 +321,8 @@ public:
KResultOr<int> sys$clock_gettime(clockid_t, Userspace<timespec*>);
KResultOr<int> sys$clock_settime(clockid_t, Userspace<const timespec*>);
KResultOr<int> sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*>);
KResultOr<int> sys$gethostname(Userspace<char*>, ssize_t);
KResultOr<int> sys$sethostname(Userspace<const char*>, ssize_t);
KResultOr<int> sys$gethostname(Userspace<char*>, size_t);
KResultOr<int> sys$sethostname(Userspace<const char*>, size_t);
KResultOr<int> sys$uname(Userspace<utsname*>);
KResultOr<int> sys$readlink(Userspace<const Syscall::SC_readlink_params*>);
KResultOr<int> sys$ttyname(int fd, Userspace<char*>, size_t);
@ -333,8 +333,8 @@ public:
KResultOr<int> sys$sigaction(int signum, Userspace<const sigaction*> act, Userspace<sigaction*> old_act);
KResultOr<int> sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set);
KResultOr<int> sys$sigpending(Userspace<sigset_t*>);
KResultOr<int> sys$getgroups(ssize_t, Userspace<gid_t*>);
KResultOr<int> sys$setgroups(ssize_t, Userspace<const gid_t*>);
KResultOr<int> sys$getgroups(size_t, Userspace<gid_t*>);
KResultOr<int> sys$setgroups(size_t, Userspace<const gid_t*>);
KResultOr<int> sys$pipe(int pipefd[2], int flags);
KResultOr<int> sys$killpg(pid_t pgrp, int sig);
KResultOr<int> sys$seteuid(uid_t);
@ -367,8 +367,8 @@ public:
KResultOr<int> sys$accept4(Userspace<const Syscall::SC_accept4_params*>);
KResultOr<int> sys$connect(int sockfd, Userspace<const sockaddr*>, socklen_t);
KResultOr<int> sys$shutdown(int sockfd, int how);
KResultOr<ssize_t> sys$sendmsg(int sockfd, Userspace<const struct msghdr*>, int flags);
KResultOr<ssize_t> sys$recvmsg(int sockfd, Userspace<struct msghdr*>, int flags);
KResultOr<size_t> sys$sendmsg(int sockfd, Userspace<const struct msghdr*>, int flags);
KResultOr<size_t> sys$recvmsg(int sockfd, Userspace<struct msghdr*>, int flags);
KResultOr<int> sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*>);
KResultOr<int> sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*>);
KResultOr<int> sys$getsockname(Userspace<const Syscall::SC_getsockname_params*>);
@ -529,7 +529,7 @@ private:
void delete_perf_events_buffer();
KResult do_exec(NonnullRefPtr<FileDescription> main_program_description, Vector<String> arguments, Vector<String> environment, RefPtr<FileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const Elf32_Ehdr& main_program_header);
KResultOr<ssize_t> do_write(FileDescription&, const UserOrKernelBuffer&, size_t);
KResultOr<size_t> do_write(FileDescription&, const UserOrKernelBuffer&, size_t);
KResultOr<int> do_statvfs(String path, statvfs* buf);

4
Kernel/Storage/StorageDevice.cpp
View file

@ -41,7 +41,7 @@ KResultOr<size_t> StorageDevice::read(FileDescription&, u64 offset, UserOrKernel
{
unsigned index = offset / block_size();
u16 whole_blocks = len / block_size();
ssize_t remaining = len % block_size();
size_t remaining = len % block_size();
unsigned blocks_per_page = PAGE_SIZE / block_size();
@ -106,7 +106,7 @@ KResultOr<size_t> StorageDevice::write(FileDescription&, u64 offset, const UserO
{
unsigned index = offset / block_size();
u16 whole_blocks = len / block_size();
ssize_t remaining = len % block_size();
size_t remaining = len % block_size();
unsigned blocks_per_page = PAGE_SIZE / block_size();

3
Kernel/Syscalls/anon_create.cpp
View file

@ -21,6 +21,9 @@ KResultOr<int> Process::sys$anon_create(size_t size, int options)
if (size % PAGE_SIZE)
return EINVAL;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
int new_fd = alloc_fd();
if (new_fd < 0)
return new_fd;

3
Kernel/Syscalls/chdir.cpp
View file

@ -45,6 +45,9 @@ KResultOr<int> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
{
REQUIRE_PROMISE(rpath);
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
auto path = current_directory().absolute_path();
size_t ideal_size = path.length() + 1;

11
Kernel/Syscalls/debug.cpp
View file

@ -23,15 +23,18 @@ KResultOr<int> Process::sys$dbgputch(u8 ch)
return 0;
}
KResultOr<size_t> Process::sys$dbgputstr(Userspace<const u8*> characters, int length)
KResultOr<size_t> Process::sys$dbgputstr(Userspace<const u8*> characters, size_t size)
{
if (length <= 0)
if (size <= 0)
return 0;
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, length);
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, size);
if (!buffer.has_value())
return EFAULT;
return buffer.value().read_buffered<1024>(length, [&](u8 const* buffer, size_t buffer_size) {
return buffer.value().read_buffered<1024>(size, [&](u8 const* buffer, size_t buffer_size) {
for (size_t i = 0; i < buffer_size; ++i)
IO::out8(IO::BOCHS_DEBUG_PORT, buffer[i]);
return buffer_size;

4
Kernel/Syscalls/get_dir_entries.cpp
View file

@ -9,10 +9,10 @@
namespace Kernel {
KResultOr<ssize_t> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, ssize_t user_size)
KResultOr<size_t> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
{
REQUIRE_PROMISE(stdio);
if (user_size < 0)
if (user_size > NumericLimits<ssize_t>::max())
return EINVAL;
auto description = file_description(fd);
if (!description)

2
Kernel/Syscalls/getrandom.cpp
View file

@ -16,7 +16,7 @@ namespace Kernel {
KResultOr<size_t> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
{
REQUIRE_PROMISE(stdio);
if (buffer_size <= 0)
if (buffer_size > NumericLimits<ssize_t>::max())
return EINVAL;
auto data_buffer = UserOrKernelBuffer::for_user_buffer(buffer, buffer_size);

6
Kernel/Syscalls/getuid.cpp
View file

@ -48,14 +48,12 @@ KResultOr<int> Process::sys$getresgid(Userspace<gid_t*> rgid, Userspace<gid_t*>
return 0;
}
KResultOr<int> Process::sys$getgroups(ssize_t count, Userspace<gid_t*> user_gids)
KResultOr<int> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
{
REQUIRE_PROMISE(stdio);
if (count < 0)
return EINVAL;
if (!count)
return extra_gids().size();
if (count != (int)extra_gids().size())
if (count != extra_gids().size())
return EINVAL;
if (!copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count))

8
Kernel/Syscalls/hostname.cpp
View file

@ -11,10 +11,10 @@ namespace Kernel {
extern String* g_hostname;
extern Lock* g_hostname_lock;
KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, ssize_t size)
KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
Locker locker(*g_hostname_lock, Lock::Mode::Shared);
if ((size_t)size < (g_hostname->length() + 1))
@ -24,13 +24,11 @@ KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, ssize_t size)
return 0;
}
KResultOr<int> Process::sys$sethostname(Userspace<const char*> hostname, ssize_t length)
KResultOr<int> Process::sys$sethostname(Userspace<const char*> hostname, size_t length)
{
REQUIRE_NO_PROMISES;
if (!is_superuser())
return EPERM;
if (length < 0)
return EINVAL;
Locker locker(*g_hostname_lock, Lock::Mode::Exclusive);
if (length > 64)
return ENAMETOOLONG;

8
Kernel/Syscalls/read.cpp
View file

@ -12,7 +12,7 @@ namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
KResultOr<size_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
REQUIRE_PROMISE(stdio);
if (iov_count < 0)
@ -68,13 +68,13 @@ KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
return nread;
}
KResultOr<ssize_t> Process::sys$read(int fd, Userspace<u8*> buffer, ssize_t size)
KResultOr<size_t> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
return EINVAL;
if (size == 0)
return 0;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
dbgln_if(IO_DEBUG, "sys$read({}, {}, {})", fd, buffer.ptr(), size);
auto description = file_description(fd);
if (!description)

4
Kernel/Syscalls/setuid.cpp
View file

@ -148,11 +148,9 @@ KResultOr<int> Process::sys$setresgid(gid_t new_rgid, gid_t new_egid, gid_t new_
return 0;
}
KResultOr<int> Process::sys$setgroups(ssize_t count, Userspace<const gid_t*> user_gids)
KResultOr<int> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
{
REQUIRE_PROMISE(id);
if (count < 0)
return EINVAL;
if (!is_superuser())
return EPERM;

11
Kernel/Syscalls/socket.cpp
View file

@ -179,7 +179,7 @@ KResultOr<int> Process::sys$shutdown(int sockfd, int how)
return socket.shutdown(how);
}
KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
KResultOr<size_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
{
REQUIRE_PROMISE(stdio);
struct msghdr msg;
@ -193,6 +193,8 @@ KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
return ENOMEM;
if (!copy_n_from_user(iovs.data(), msg.msg_iov, msg.msg_iovlen))
return EFAULT;
if (iovs[0].iov_len > NumericLimits<ssize_t>::max())
return EINVAL;
Userspace<const sockaddr*> user_addr((FlatPtr)msg.msg_name);
socklen_t addr_length = msg.msg_namelen;
@ -208,13 +210,10 @@ KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
auto data_buffer = UserOrKernelBuffer::for_user_buffer((u8*)iovs[0].iov_base, iovs[0].iov_len);
if (!data_buffer.has_value())
return EFAULT;
auto result = socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
if (result.is_error())
return result.error();
return result.value();
return socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
}
KResultOr<ssize_t> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
KResultOr<size_t> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
{
REQUIRE_PROMISE(stdio);

12
Kernel/Syscalls/write.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<ssize_t> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
KResultOr<size_t> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
REQUIRE_PROMISE(stdio);
if (iov_count < 0)
@ -57,9 +57,9 @@ KResultOr<ssize_t> Process::sys$writev(int fd, Userspace<const struct iovec*> io
return nwritten;
}
KResultOr<ssize_t> Process::do_write(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
KResultOr<size_t> Process::do_write(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
{
ssize_t total_nwritten = 0;
size_t total_nwritten = 0;
if (description.should_append() && description.file().is_seekable()) {
auto seek_result = description.seek(0, SEEK_END);
@ -96,13 +96,13 @@ KResultOr<ssize_t> Process::do_write(FileDescription& description, const UserOrK
return total_nwritten;
}
KResultOr<ssize_t> Process::sys$write(int fd, Userspace<const u8*> data, ssize_t size)
KResultOr<size_t> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
return EINVAL;
if (size == 0)
return 0;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
dbgln_if(IO_DEBUG, "sys$write({}, {}, {})", fd, data.ptr(), size);
auto description = file_description(fd);

9
Kernel/UserOrKernelBuffer.h
View file

@ -44,7 +44,7 @@ public:
[[nodiscard]] bool is_kernel_buffer() const;
[[nodiscard]] const void* user_or_kernel_ptr() const { return m_buffer; }
[[nodiscard]] UserOrKernelBuffer offset(ssize_t offset) const
[[nodiscard]] UserOrKernelBuffer offset(size_t offset) const
{
if (!m_buffer)
return *this;
@ -97,9 +97,10 @@ public:
size_t nwritten = 0;
while (nwritten < len) {
auto to_copy = min(sizeof(buffer), len - nwritten);
ssize_t copied = f(buffer, to_copy);
if (copied < 0)
return copied;
KResultOr<size_t> copied_or_error = f(buffer, to_copy);
if (copied_or_error.is_error())
return copied_or_error.error();
auto copied = copied_or_error.value();
VERIFY((size_t)copied <= to_copy);
if (!write(buffer, nwritten, (size_t)copied))
return EFAULT;

2
Kernel/VM/Region.cpp
View file

@ -541,7 +541,7 @@ PageFaultResponse Region::handle_inode_fault(size_t page_index_in_region, Scoped
// Reading the page may block, so release the MM lock temporarily
mm_lock.unlock();
KResultOr<ssize_t> result(KSuccess);
KResultOr<size_t> result(KSuccess);
{
ScopedLockRelease release_paging_lock(vmobject().m_paging_lock);
auto buffer = UserOrKernelBuffer::for_kernel_buffer(page_buffer);