RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-10-31 20:52:45 +00:00
Code Issues Activity Actions

Kernel: Make UserOrKernelBuffer return KResult from read/write/memset

Browse source 
This allows us to simplify a whole bunch of call sites with TRY(). :^)
This commit is contained in:
Andreas Kling 2021-09-07 12:09:52 +02:00
parent 7bf8844499
commit b481132418
29 changed files with 85 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Kernel/ACPI/Parser.cpp
View file

@ -41,8 +41,7 @@ KResultOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, Use
return KSuccess;
ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
if (!buffer.write(blob->data() + offset, nread))
return KResult(EFAULT);
TRY(buffer.write(blob->data() + offset, nread));
return nread;
}

3
Kernel/Arch/PC/BIOS.cpp
View file

@ -39,8 +39,7 @@ KResultOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, Use
return KSuccess;
ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
if (!buffer.write(blob->data() + offset, nread))
return KResult(EFAULT);
TRY(buffer.write(blob->data() + offset, nread));
return nread;
}

3
Kernel/Bus/PCI/SysFSPCI.cpp
View file

@ -70,8 +70,7 @@ KResultOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, siz
return KSuccess;
ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
if (!buffer.write(blob->data() + offset, nread))
return KResult(EFAULT);
TRY(buffer.write(blob->data() + offset, nread));
return nread;
}

4
Kernel/Bus/USB/SysFSUSB.cpp
View file

@ -87,9 +87,7 @@ KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t cou
return 0;
ssize_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 KResult(EFAULT);
TRY(buffer.write(data_buffer->data() + offset, nread));
return nread;
}

4
Kernel/Devices/AsyncDeviceRequest.h
View file

@ -81,7 +81,7 @@ public:
void* get_private() const { return m_private; }
template<typename... Args>
[[nodiscard]] bool write_to_buffer(UserOrKernelBuffer& buffer, Args... args)
KResult write_to_buffer(UserOrKernelBuffer& buffer, Args... args)
{
if (in_target_context(buffer))
return buffer.write(forward<Args>(args)...);
@ -99,7 +99,7 @@ public:
}
template<typename... Args>
[[nodiscard]] bool read_from_buffer(const UserOrKernelBuffer& buffer, Args... args)
KResult read_from_buffer(const UserOrKernelBuffer& buffer, Args... args)
{
if (in_target_context(buffer))
return buffer.read(forward<Args>(args)...);

3
Kernel/Devices/FullDevice.cpp
View file

@ -32,8 +32,7 @@ bool FullDevice::can_read(const FileDescription&, size_t) const
KResultOr<size_t> FullDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
{
if (!buffer.memset(0, size))
return EFAULT;
TRY(buffer.memset(0, size));
return size;
}

3
Kernel/Devices/HID/MouseDevice.cpp
View file

@ -39,8 +39,7 @@ KResultOr<size_t> MouseDevice::read(FileDescription&, u64, UserOrKernelBuffer& b
dbgln_if(MOUSE_DEBUG, "PS2 Mouse Read: Filter packets");
size_t bytes_read_from_packet = min(remaining_space_in_buffer, sizeof(MousePacket));
if (!buffer.write(&packet, nread, bytes_read_from_packet))
return EFAULT;
TRY(buffer.write(&packet, nread, bytes_read_from_packet));
nread += bytes_read_from_packet;
remaining_space_in_buffer -= bytes_read_from_packet;

3
Kernel/Devices/SB16.cpp
View file

@ -276,8 +276,7 @@ KResultOr<size_t> SB16::write(FileDescription&, u64, UserOrKernelBuffer const& d
u8 mode = (u8)SampleFormat::Signed | (u8)SampleFormat::Stereo;
if (!data.read(m_dma_region->vaddr().as_ptr(), length))
return EFAULT;
TRY(data.read(m_dma_region->vaddr().as_ptr(), length));
dma_start(length);
// 16-bit single-cycle output.

3
Kernel/Devices/ZeroDevice.cpp
View file

@ -31,8 +31,7 @@ bool ZeroDevice::can_read(const FileDescription&, size_t) const
KResultOr<size_t> ZeroDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
{
if (!buffer.memset(0, size))
return EFAULT;
TRY(buffer.memset(0, size));
return size;
}

9
Kernel/DoubleBuffer.cpp
View file

@ -57,8 +57,7 @@ KResultOr<size_t> DoubleBuffer::write(const UserOrKernelBuffer& data, size_t siz
MutexLocker locker(m_lock);
size_t bytes_to_write = min(size, m_space_for_writing);
u8* write_ptr = m_write_buffer->data + m_write_buffer->size;
if (!data.read(write_ptr, bytes_to_write))
return EFAULT;
TRY(data.read(write_ptr, bytes_to_write));
m_write_buffer->size += bytes_to_write;
compute_lockfree_metadata();
if (m_unblock_callback && !m_empty)
@ -76,8 +75,7 @@ KResultOr<size_t> DoubleBuffer::read(UserOrKernelBuffer& data, size_t size)
if (m_read_buffer_index >= m_read_buffer->size)
return 0;
size_t nread = min(m_read_buffer->size - m_read_buffer_index, size);
if (!data.write(m_read_buffer->data + m_read_buffer_index, nread))
return EFAULT;
TRY(data.write(m_read_buffer->data + m_read_buffer_index, nread));
m_read_buffer_index += nread;
compute_lockfree_metadata();
if (m_unblock_callback && m_space_for_writing > 0)
@ -96,8 +94,7 @@ KResultOr<size_t> DoubleBuffer::peek(UserOrKernelBuffer& data, size_t size)
if (m_read_buffer_index >= m_read_buffer->size)
return 0;
size_t nread = min(m_read_buffer->size - m_read_buffer_index, size);
if (!data.write(m_read_buffer->data + m_read_buffer_index, nread))
return EFAULT;
TRY(data.write(m_read_buffer->data + m_read_buffer_index, nread));
compute_lockfree_metadata();
if (m_unblock_callback && m_space_for_writing > 0)
m_unblock_callback();

7
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -156,8 +156,7 @@ KResult BlockBasedFileSystem::write_block(BlockIndex index, const UserOrKernelBu
// Fill the cache first.
TRY(read_block(index, nullptr, block_size()));
}
if (!data.read(entry.data + offset, count))
return EFAULT;
TRY(data.read(entry.data + offset, count));
cache->mark_dirty(entry);
entry.has_data = true;
@ -238,8 +237,8 @@ KResult BlockBasedFileSystem::read_block(BlockIndex index, UserOrKernelBuffer* b
VERIFY(nread == block_size());
entry.has_data = true;
}
if (buffer && !buffer->write(entry.data + offset, count))
return EFAULT;
if (buffer)
TRY(buffer->write(entry.data + offset, count));
return KSuccess;
});
}

3
Kernel/FileSystem/DevFS.cpp
View file

@ -154,8 +154,7 @@ KResultOr<size_t> DevFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelB
MutexLocker locker(m_inode_lock);
VERIFY(offset == 0);
VERIFY(m_link);
if (!buffer.write(m_link->characters() + offset, m_link->length()))
return EFAULT;
TRY(buffer.write(m_link->characters() + offset, m_link->length()));
return m_link->length();
}

9
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -842,8 +842,7 @@ KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKern
if (is_symlink() && size() < max_inline_symlink_length) {
VERIFY(offset == 0);
size_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
if (!buffer.write(((const u8*)m_raw_inode.i_block) + offset, nread))
return EFAULT;
TRY(buffer.write(((const u8*)m_raw_inode.i_block) + offset, nread));
return nread;
}
@ -878,8 +877,7 @@ KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKern
auto buffer_offset = buffer.offset(nread);
if (block_index.value() == 0) {
// This is a hole, act as if it's filled with zeroes.
if (!buffer_offset.memset(0, num_bytes_to_copy))
return EFAULT;
TRY(buffer_offset.memset(0, num_bytes_to_copy));
} else {
if (auto result = fs().read_block(block_index, &buffer_offset, num_bytes_to_copy, offset_into_block, allow_cache); result.is_error()) {
dmesgln("Ext2FSInode[{}]::read_bytes(): Failed to read block {} (index {})", identifier(), block_index.value(), bi);
@ -982,8 +980,7 @@ KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const Use
VERIFY(offset == 0);
if (max((size_t)(offset + count), (size_t)m_raw_inode.i_size) < max_inline_symlink_length) {
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::write_bytes(): Poking into i_block array for inline symlink ({} bytes)", identifier(), count);
if (!data.read(((u8*)m_raw_inode.i_block) + offset, (size_t)count))
return EFAULT;
TRY(data.read(((u8*)m_raw_inode.i_block) + offset, count));
if ((size_t)(offset + count) > (size_t)m_raw_inode.i_size)
m_raw_inode.i_size = offset + count;
set_metadata_dirty(true);

5
Kernel/FileSystem/FileDescription.cpp
View file

@ -222,8 +222,9 @@ KResultOr<size_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_bu
if (remaining < stream.size()) {
error = EINVAL;
return false;
} else if (!output_buffer.write(stream.bytes())) {
error = EFAULT;
}
if (auto result = output_buffer.write(stream.bytes()); result.is_error()) {
error = result.release_error();
return false;
}
output_buffer = output_buffer.offset(stream.size());

5
Kernel/FileSystem/ISO9660FileSystem.cpp
View file

@ -446,10 +446,7 @@ KResultOr<size_t> ISO9660Inode::read_bytes(off_t offset, size_t size, UserOrKern
return EIO;
}
bool result = buffer_offset.write(block->data() + initial_offset, bytes_to_read);
if (!result) {
return EFAULT;
}
TRY(buffer_offset.write(block->data() + initial_offset, bytes_to_read));
nread += bytes_to_read;
initial_offset = 0;

4
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -745,9 +745,7 @@ KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKern
// Guard against the server returning more data than requested.
size_t nread = min(data.length(), size);
if (!buffer.write(data.characters_without_null_termination(), nread))
return EFAULT;
TRY(buffer.write(data.characters_without_null_termination(), nread));
return nread;
}

6
Kernel/FileSystem/ProcFS.cpp
View file

@ -489,8 +489,7 @@ KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t co
if (!data_buffer)
return KResult(EFAULT);
ssize_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 KResult(EFAULT);
TRY(buffer.write(data_buffer->data() + offset, nread));
return nread;
}
if (!description->data()) {
@ -507,8 +506,7 @@ KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t co
return 0;
ssize_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 KResult(EFAULT);
TRY(buffer.write(data_buffer->data() + offset, nread));
return nread;
}

6
Kernel/FileSystem/TmpFS.cpp
View file

@ -138,8 +138,7 @@ KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernel
if (static_cast<off_t>(size) > m_metadata.size - offset)
size = m_metadata.size - offset;
if (!buffer.write(m_content->data() + offset, size))
return EFAULT;
TRY(buffer.write(m_content->data() + offset, size));
return size;
}
@ -182,8 +181,7 @@ KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserO
notify_watchers();
}
if (!buffer.read(m_content->data() + offset, size)) // TODO: partial reads?
return EFAULT;
TRY(buffer.read(m_content->data() + offset, size)); // TODO: partial reads?
did_modify_contents();
return size;

8
Kernel/Memory/RingBuffer.cpp
View file

@ -22,20 +22,18 @@ bool RingBuffer::copy_data_in(const UserOrKernelBuffer& buffer, size_t offset, s
bytes_copied = min(m_capacity_in_bytes - m_num_used_bytes, min(m_capacity_in_bytes - start_of_free_area, length));
if (bytes_copied == 0)
return false;
if (buffer.read(m_region->vaddr().offset(start_of_free_area).as_ptr(), offset, bytes_copied)) {
if (auto result = buffer.read(m_region->vaddr().offset(start_of_free_area).as_ptr(), offset, bytes_copied); result.is_error())
return false;
m_num_used_bytes += bytes_copied;
start_of_copied_data = m_region->physical_page(start_of_free_area / PAGE_SIZE)->paddr().offset(start_of_free_area % PAGE_SIZE);
return true;
}
return false;
}
KResultOr<size_t> RingBuffer::copy_data_out(size_t size, UserOrKernelBuffer& buffer) const
{
auto start = m_start_of_used % m_capacity_in_bytes;
auto num_bytes = min(min(m_num_used_bytes, size), m_capacity_in_bytes - start);
if (!buffer.write(m_region->vaddr().offset(start).as_ptr(), num_bytes))
return EIO;
TRY(buffer.write(m_region->vaddr().offset(start).as_ptr(), num_bytes));
return num_bytes;
}

8
Kernel/Net/IPv4Socket.cpp
View file

@ -236,9 +236,9 @@ KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer&
return set_so_error(ENOMEM);
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(), routing_decision.next_hop,
m_peer_address, (IPv4Protocol)protocol(), data_length, m_ttl);
if (!data.read(packet->buffer->data() + ipv4_payload_offset, data_length)) {
if (auto result = data.read(packet->buffer->data() + ipv4_payload_offset, data_length); result.is_error()) {
routing_decision.adapter->release_packet_buffer(*packet);
return set_so_error(EFAULT);
return set_so_error(result);
}
routing_decision.adapter->send_packet(packet->bytes());
routing_decision.adapter->release_packet_buffer(*packet);
@ -371,8 +371,8 @@ KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& descripti
if (type() == SOCK_RAW) {
size_t bytes_written = min(packet.data.value().size(), buffer_length);
if (!buffer.write(packet.data.value().data(), bytes_written))
return set_so_error(EFAULT);
if (auto result = buffer.write(packet.data.value().data(), bytes_written); result.is_error())
return set_so_error(result);
return bytes_written;
}

10
Kernel/Net/TCPSocket.cpp
View file

@ -169,8 +169,8 @@ KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, Use
size_t payload_size = raw_ipv4_packet.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
dbgln_if(TCP_SOCKET_DEBUG, "payload_size {}, will it fit in {}?", payload_size, buffer_size);
VERIFY(buffer_size >= payload_size);
if (!buffer.write(tcp_packet.payload(), payload_size))
return set_so_error(EFAULT);
if (auto result = buffer.write(tcp_packet.payload(), payload_size); result.is_error())
return set_so_error(result);
return payload_size;
}
@ -226,9 +226,11 @@ KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload,
tcp_packet.set_ack_number(m_ack_number);
}
if (payload && !payload->read(tcp_packet.payload(), payload_size)) {
if (payload) {
if (auto result = payload->read(tcp_packet.payload(), payload_size); result.is_error()) {
routing_decision.adapter->release_packet_buffer(*packet);
return set_so_error(EFAULT);
return set_so_error(result);
}
}
if (flags & TCPFlags::SYN) {

8
Kernel/Net/UDPSocket.cpp
View file

@ -65,8 +65,8 @@ KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, Use
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
VERIFY(udp_packet.length() >= sizeof(UDPPacket)); // FIXME: This should be rejected earlier.
size_t read_size = min(buffer_size, udp_packet.length() - sizeof(UDPPacket));
if (!buffer.write(udp_packet.payload(), read_size))
return set_so_error(EFAULT);
if (auto result = buffer.write(udp_packet.payload(), read_size); result.is_error())
return set_so_error(result);
return read_size;
}
@ -86,8 +86,8 @@ KResultOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_
udp_packet.set_source_port(local_port());
udp_packet.set_destination_port(peer_port());
udp_packet.set_length(udp_buffer_size);
if (!data.read(udp_packet.payload(), data_length))
return set_so_error(EFAULT);
if (auto result = data.read(udp_packet.payload(), data_length); result.is_error())
return set_so_error(result);
routing_decision.adapter->fill_in_ipv4_header(*packet, local_address(), routing_decision.next_hop,
peer_address(), IPv4Protocol::UDP, udp_buffer_size, ttl());

7
Kernel/ProcessExposed.cpp
View file

@ -131,9 +131,7 @@ KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count
return 0;
ssize_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 KResult(EFAULT);
TRY(buffer.write(data_buffer->data() + offset, nread));
return nread;
}
@ -167,8 +165,7 @@ KResultOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, User
return KResult(EFAULT);
ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
if (!buffer.write(blob->data() + offset, nread))
return KResult(EFAULT);
TRY(buffer.write(blob->data() + offset, nread));
return nread;
}

4
Kernel/Storage/AHCIPort.cpp
View file

@ -103,7 +103,7 @@ void AHCIPort::handle_interrupt()
VERIFY(m_current_request);
VERIFY(m_current_scatter_list);
if (m_current_request->request_type() == AsyncBlockDeviceRequest::Read) {
if (!m_current_request->write_to_buffer(m_current_request->buffer(), m_current_scatter_list->dma_region().as_ptr(), m_connected_device->block_size() * m_current_request->block_count())) {
if (auto result = m_current_request->write_to_buffer(m_current_request->buffer(), m_current_scatter_list->dma_region().as_ptr(), m_connected_device->block_size() * m_current_request->block_count()); result.is_error()) {
dbgln_if(AHCI_DEBUG, "AHCI Port {}: Request failure, memory fault occurred when reading in data.", representative_port_index());
m_current_scatter_list = nullptr;
complete_current_request(AsyncDeviceRequest::MemoryFault);
@ -445,7 +445,7 @@ Optional<AsyncDeviceRequest::RequestResult> AHCIPort::prepare_and_set_scatter_li
if (!m_current_scatter_list)
return AsyncDeviceRequest::Failure;
if (request.request_type() == AsyncBlockDeviceRequest::Write) {
if (!request.read_from_buffer(request.buffer(), m_current_scatter_list->dma_region().as_ptr(), m_connected_device->block_size() * request.block_count())) {
if (auto result = request.read_from_buffer(request.buffer(), m_current_scatter_list->dma_region().as_ptr(), m_connected_device->block_size() * request.block_count()); result.is_error()) {
return AsyncDeviceRequest::MemoryFault;
}
}

4
Kernel/Storage/BMIDEChannel.cpp
View file

@ -135,7 +135,7 @@ void BMIDEChannel::complete_current_request(AsyncDeviceRequest::RequestResult re
if (result == AsyncDeviceRequest::Success) {
if (current_request->request_type() == AsyncBlockDeviceRequest::Read) {
if (!current_request->write_to_buffer(current_request->buffer(), m_dma_buffer_region->vaddr().as_ptr(), 512 * current_request->block_count())) {
if (auto result = current_request->write_to_buffer(current_request->buffer(), m_dma_buffer_region->vaddr().as_ptr(), 512 * current_request->block_count()); result.is_error()) {
lock.unlock();
current_request->complete(AsyncDeviceRequest::MemoryFault);
return;
@ -164,7 +164,7 @@ void BMIDEChannel::ata_write_sectors(bool slave_request, u16 capabilities)
prdt().offset = m_dma_buffer_page->paddr().get();
prdt().size = 512 * m_current_request->block_count();
if (!m_current_request->read_from_buffer(m_current_request->buffer(), m_dma_buffer_region->vaddr().as_ptr(), 512 * m_current_request->block_count())) {
if (auto result = m_current_request->read_from_buffer(m_current_request->buffer(), m_dma_buffer_region->vaddr().as_ptr(), 512 * m_current_request->block_count()); result.is_error()) {
complete_current_request(AsyncDeviceRequest::MemoryFault);
return;
}

10
Kernel/Storage/RamdiskDevice.cpp
View file

@ -45,15 +45,13 @@ void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request)
if ((offset + length > base + size) || (offset + length < base)) {
request.complete(AsyncDeviceRequest::Failure);
} else {
bool success;
auto result = KResult(KSuccess);
if (request.request_type() == AsyncBlockDeviceRequest::Read) {
success = request.buffer().write(offset, length);
result = request.buffer().write(offset, length);
} else {
success = request.buffer().read(offset, length);
result = request.buffer().read(offset, length);
}
request.complete(success ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
request.complete(result.is_success() ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
}
}

6
Kernel/Storage/StorageDevice.cpp
View file

@ -93,8 +93,7 @@ KResultOr<size_t> StorageDevice::read(FileDescription&, u64 offset, UserOrKernel
default:
break;
}
if (!outbuf.write(data.data(), pos, remaining))
return EFAULT;
TRY(outbuf.write(data.data(), pos, remaining));
}
return pos + remaining;
@ -166,8 +165,7 @@ KResultOr<size_t> StorageDevice::write(FileDescription&, u64 offset, const UserO
}
}
if (!inbuf.read(data.data(), pos, remaining))
return EFAULT;
TRY(inbuf.read(data.data(), pos, remaining));
{
auto write_request = make_request<AsyncBlockDeviceRequest>(AsyncBlockDeviceRequest::Write, index + whole_blocks, 1, data_buffer, block_size());

24
Kernel/UserOrKernelBuffer.cpp
View file

@ -29,40 +29,40 @@ KResultOr<NonnullOwnPtr<KString>> UserOrKernelBuffer::try_copy_into_kstring(size
return KString::try_create(ReadonlyBytes { m_buffer, size });
}
bool UserOrKernelBuffer::write(const void* src, size_t offset, size_t len)
KResult UserOrKernelBuffer::write(void const* src, size_t offset, size_t len)
{
if (!m_buffer)
return false;
return EFAULT;
if (Memory::is_user_address(VirtualAddress(m_buffer)))
return copy_to_user(m_buffer + offset, src, len).is_success();
return copy_to_user(m_buffer + offset, src, len);
memcpy(m_buffer + offset, src, len);
return true;
return KSuccess;
}
bool UserOrKernelBuffer::read(void* dest, size_t offset, size_t len) const
KResult UserOrKernelBuffer::read(void* dest, size_t offset, size_t len) const
{
if (!m_buffer)
return false;
return EFAULT;
if (Memory::is_user_address(VirtualAddress(m_buffer)))
return copy_from_user(dest, m_buffer + offset, len).is_success();
return copy_from_user(dest, m_buffer + offset, len);
memcpy(dest, m_buffer + offset, len);
return true;
return KSuccess;
}
bool UserOrKernelBuffer::memset(int value, size_t offset, size_t len)
KResult UserOrKernelBuffer::memset(int value, size_t offset, size_t len)
{
if (!m_buffer)
return false;
return EFAULT;
if (Memory::is_user_address(VirtualAddress(m_buffer)))
return memset_user(m_buffer + offset, value, len).is_success();
return memset_user(m_buffer + offset, value, len);
::memset(m_buffer + offset, value, len);
return true;
return KSuccess;
}
}

23
Kernel/UserOrKernelBuffer.h
View file

@ -55,28 +55,29 @@ public:
}
KResultOr<NonnullOwnPtr<KString>> try_copy_into_kstring(size_t) const;
[[nodiscard]] bool write(const void* src, size_t offset, size_t len);
[[nodiscard]] bool write(const void* src, size_t len)
KResult write(const void* src, size_t offset, size_t len);
KResult write(const void* src, size_t len)
{
return write(src, 0, len);
}
[[nodiscard]] bool write(ReadonlyBytes bytes)
KResult write(ReadonlyBytes bytes)
{
return write(bytes.data(), bytes.size());
}
[[nodiscard]] bool read(void* dest, size_t offset, size_t len) const;
[[nodiscard]] bool read(void* dest, size_t len) const
KResult read(void* dest, size_t offset, size_t len) const;
KResult read(void* dest, size_t len) const
{
return read(dest, 0, len);
}
[[nodiscard]] bool read(Bytes bytes) const
KResult read(Bytes bytes) const
{
return read(bytes.data(), bytes.size());
}
[[nodiscard]] bool memset(int value, size_t offset, size_t len);
[[nodiscard]] bool memset(int value, size_t len)
KResult memset(int value, size_t offset, size_t len);
KResult memset(int value, size_t len)
{
return memset(value, 0, len);
}
@ -104,8 +105,7 @@ public:
return copied_or_error.error();
auto copied = copied_or_error.value();
VERIFY(copied <= to_copy);
if (!write(buffer, nwritten, copied))
return EFAULT;
TRY(write(buffer, nwritten, copied));
nwritten += copied;
if (copied < to_copy)
break;
@ -134,8 +134,7 @@ public:
size_t nread = 0;
while (nread < len) {
auto to_copy = min(sizeof(buffer), len - nread);
if (!read(buffer, nread, to_copy))
return EFAULT;
TRY(read(buffer, nread, to_copy));
ReadonlyBytes read_only_bytes { buffer, to_copy };
KResultOr<size_t> copied_or_error = f(read_only_bytes);
if (copied_or_error.is_error())