From 668c4299000e013852bd07e5df81750db672d607 Mon Sep 17 00:00:00 2001 From: Brian Gianforcaro Date: Tue, 31 Aug 2021 23:44:55 -0700 Subject: [PATCH] Kernel: Convert UserOrKernelBuffer callbacks to use AK::Bytes --- Kernel/ConsoleDevice.cpp | 8 ++++---- Kernel/Devices/HID/KeyboardDevice.cpp | 6 +++--- Kernel/Devices/RandomDevice.cpp | 6 +++--- Kernel/Devices/SerialDevice.cpp | 16 ++++++++-------- Kernel/FileSystem/InodeWatcher.cpp | 14 +++++++------- Kernel/Storage/IDEChannel.cpp | 16 ++++++++-------- Kernel/Syscalls/getrandom.cpp | 6 +++--- Kernel/TTY/SlavePTY.cpp | 8 ++++---- Kernel/TTY/TTY.cpp | 14 +++++++------- Kernel/TTY/VirtualConsole.cpp | 8 ++++---- Kernel/UserOrKernelBuffer.h | 11 +++++++---- 11 files changed, 58 insertions(+), 55 deletions(-) diff --git a/Kernel/ConsoleDevice.cpp b/Kernel/ConsoleDevice.cpp index 282a1ae010..9cfd55b7f8 100644 --- a/Kernel/ConsoleDevice.cpp +++ b/Kernel/ConsoleDevice.cpp @@ -58,10 +58,10 @@ Kernel::KResultOr ConsoleDevice::write(FileDescription&, u64, const Kern if (!size) return 0; - return data.read_buffered<256>(size, [&](u8 const* bytes, size_t bytes_count) { - for (size_t i = 0; i < bytes_count; i++) - put_char((char)bytes[i]); - return bytes_count; + return data.read_buffered<256>(size, [&](ReadonlyBytes readonly_bytes) { + for (const auto& byte : readonly_bytes) + put_char(byte); + return readonly_bytes.size(); }); } diff --git a/Kernel/Devices/HID/KeyboardDevice.cpp b/Kernel/Devices/HID/KeyboardDevice.cpp index 85c5611d18..485d5ccbb3 100644 --- a/Kernel/Devices/HID/KeyboardDevice.cpp +++ b/Kernel/Devices/HID/KeyboardDevice.cpp @@ -292,9 +292,9 @@ KResultOr KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer lock.unlock(); - auto result = buffer.write_buffered(sizeof(Event), [&](u8* data, size_t data_bytes) { - memcpy(data, &event, sizeof(Event)); - return data_bytes; + auto result = buffer.write_buffered(sizeof(Event), [&](Bytes bytes) { + memcpy(bytes.data(), &event, sizeof(Event)); + return bytes.size(); }); if (result.is_error()) return result.error(); diff --git a/Kernel/Devices/RandomDevice.cpp b/Kernel/Devices/RandomDevice.cpp index caf06614b7..9c4503d7bc 100644 --- a/Kernel/Devices/RandomDevice.cpp +++ b/Kernel/Devices/RandomDevice.cpp @@ -31,9 +31,9 @@ bool RandomDevice::can_read(const FileDescription&, size_t) const KResultOr RandomDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size) { - return buffer.write_buffered<256>(size, [&](u8* data, size_t data_size) { - get_good_random_bytes({ data, data_size }); - return data_size; + return buffer.write_buffered<256>(size, [&](Bytes bytes) { + get_good_random_bytes(bytes); + return bytes.size(); }); } diff --git a/Kernel/Devices/SerialDevice.cpp b/Kernel/Devices/SerialDevice.cpp index 5b6b2dac3d..a84491f538 100644 --- a/Kernel/Devices/SerialDevice.cpp +++ b/Kernel/Devices/SerialDevice.cpp @@ -63,10 +63,10 @@ KResultOr SerialDevice::read(FileDescription&, u64, UserOrKernelBuffer& if (!(get_line_status() & DataReady)) return 0; - return buffer.write_buffered<128>(size, [&](u8* data, size_t data_size) { - for (size_t i = 0; i < data_size; i++) - data[i] = m_base_addr.in(); - return data_size; + return buffer.write_buffered<128>(size, [&](Bytes bytes) { + for (auto& byte : bytes) + byte = m_base_addr.in(); + return bytes.size(); }); } @@ -84,10 +84,10 @@ KResultOr SerialDevice::write(FileDescription& description, u64, const U if (!can_write(description, size)) return EAGAIN; - return buffer.read_buffered<128>(size, [&](u8 const* data, size_t data_size) { - for (size_t i = 0; i < data_size; i++) - put_char(data[i]); - return data_size; + return buffer.read_buffered<128>(size, [&](ReadonlyBytes bytes) { + for (const auto& byte : bytes) + put_char(byte); + return bytes.size(); }); } diff --git a/Kernel/FileSystem/InodeWatcher.cpp b/Kernel/FileSystem/InodeWatcher.cpp index 0f3153b62d..f8b30e993e 100644 --- a/Kernel/FileSystem/InodeWatcher.cpp +++ b/Kernel/FileSystem/InodeWatcher.cpp @@ -48,23 +48,23 @@ KResultOr InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer& if (buffer_size < bytes_to_write) return EINVAL; - auto result = buffer.write_buffered(bytes_to_write, [&](u8* data, size_t data_bytes) { + auto result = buffer.write_buffered(bytes_to_write, [&](Bytes bytes) { size_t offset = 0; - memcpy(data + offset, &event.wd, sizeof(InodeWatcherEvent::watch_descriptor)); + memcpy(bytes.offset(offset), &event.wd, sizeof(InodeWatcherEvent::watch_descriptor)); offset += sizeof(InodeWatcherEvent::watch_descriptor); - memcpy(data + offset, &event.type, sizeof(InodeWatcherEvent::type)); + memcpy(bytes.offset(offset), &event.type, sizeof(InodeWatcherEvent::type)); offset += sizeof(InodeWatcherEvent::type); if (!event.path.is_null()) { - memcpy(data + offset, &name_length, sizeof(InodeWatcherEvent::name_length)); + memcpy(bytes.offset(offset), &name_length, sizeof(InodeWatcherEvent::name_length)); offset += sizeof(InodeWatcherEvent::name_length); - memcpy(data + offset, event.path.characters(), name_length); + memcpy(bytes.offset(offset), event.path.characters(), name_length); } else { - memset(data + offset, 0, sizeof(InodeWatcherEvent::name_length)); + memset(bytes.offset(offset), 0, sizeof(InodeWatcherEvent::name_length)); } - return data_bytes; + return bytes.size(); }); evaluate_block_conditions(); return result; diff --git a/Kernel/Storage/IDEChannel.cpp b/Kernel/Storage/IDEChannel.cpp index b5933b7a60..46286c7c4f 100644 --- a/Kernel/Storage/IDEChannel.cpp +++ b/Kernel/Storage/IDEChannel.cpp @@ -478,10 +478,10 @@ bool IDEChannel::ata_do_read_sector() dbgln_if(PATA_DEBUG, "IDEChannel::ata_do_read_sector"); auto& request = *m_current_request; auto out_buffer = request.buffer().offset(m_current_request_block_index * 512); - auto result = request.write_to_buffer_buffered<512>(out_buffer, 512, [&](u8* buffer, size_t buffer_bytes) { - for (size_t i = 0; i < buffer_bytes; i += sizeof(u16)) - *(u16*)&buffer[i] = IO::in16(m_io_group.io_base().offset(ATA_REG_DATA).get()); - return buffer_bytes; + auto result = request.write_to_buffer_buffered<512>(out_buffer, 512, [&](Bytes bytes) { + for (size_t i = 0; i < bytes.size(); i += sizeof(u16)) + *(u16*)bytes.offset_pointer(i) = IO::in16(m_io_group.io_base().offset(ATA_REG_DATA).get()); + return bytes.size(); }); if (result.is_error()) { // TODO: Do we need to abort the PATA read if this wasn't the last block? @@ -520,10 +520,10 @@ void IDEChannel::ata_do_write_sector() auto in_buffer = request.buffer().offset(m_current_request_block_index * 512); dbgln_if(PATA_DEBUG, "IDEChannel: Writing 512 bytes (part {}) (status={:#02x})...", m_current_request_block_index, status); - auto result = request.read_from_buffer_buffered<512>(in_buffer, 512, [&](u8 const* buffer, size_t buffer_bytes) { - for (size_t i = 0; i < buffer_bytes; i += sizeof(u16)) - IO::out16(m_io_group.io_base().offset(ATA_REG_DATA).get(), *(const u16*)&buffer[i]); - return buffer_bytes; + auto result = request.read_from_buffer_buffered<512>(in_buffer, 512, [&](ReadonlyBytes readonly_bytes) { + for (size_t i = 0; i < readonly_bytes.size(); i += sizeof(u16)) + IO::out16(m_io_group.io_base().offset(ATA_REG_DATA).get(), *(const u16*)readonly_bytes.offset(i)); + return readonly_bytes.size(); }); if (result.is_error()) complete_current_request(AsyncDeviceRequest::MemoryFault); diff --git a/Kernel/Syscalls/getrandom.cpp b/Kernel/Syscalls/getrandom.cpp index f5175981aa..dfc14c8ae9 100644 --- a/Kernel/Syscalls/getrandom.cpp +++ b/Kernel/Syscalls/getrandom.cpp @@ -23,9 +23,9 @@ KResultOr Process::sys$getrandom(Userspace buffer, size_t buffer auto data_buffer = UserOrKernelBuffer::for_user_buffer(buffer, buffer_size); if (!data_buffer.has_value()) return EFAULT; - auto result = data_buffer.value().write_buffered<1024>(buffer_size, [&](u8* buffer, size_t buffer_bytes) { - get_good_random_bytes({ buffer, buffer_bytes }); - return buffer_bytes; + auto result = data_buffer.value().write_buffered<1024>(buffer_size, [&](Bytes bytes) { + get_good_random_bytes(bytes); + return bytes.size(); }); if (result.is_error()) return result.error(); diff --git a/Kernel/TTY/SlavePTY.cpp b/Kernel/TTY/SlavePTY.cpp index f6bdfc5cdc..a43735a15d 100644 --- a/Kernel/TTY/SlavePTY.cpp +++ b/Kernel/TTY/SlavePTY.cpp @@ -67,10 +67,10 @@ void SlavePTY::echo(u8 ch) void SlavePTY::on_master_write(const UserOrKernelBuffer& buffer, size_t size) { - auto result = buffer.read_buffered<128>(size, [&](u8 const* data, size_t data_size) { - for (size_t i = 0; i < data_size; ++i) - emit(data[i], false); - return data_size; + auto result = buffer.read_buffered<128>(size, [&](ReadonlyBytes data) { + for (const auto& byte : data) + emit(byte, false); + return data.size(); }); if (!result.is_error()) evaluate_block_conditions(); diff --git a/Kernel/TTY/TTY.cpp b/Kernel/TTY/TTY.cpp index 7073b5a554..49719c4066 100644 --- a/Kernel/TTY/TTY.cpp +++ b/Kernel/TTY/TTY.cpp @@ -52,9 +52,9 @@ KResultOr TTY::read(FileDescription&, u64, UserOrKernelBuffer& buffer, s size = m_input_buffer.size(); bool need_evaluate_block_conditions = false; - auto result = buffer.write_buffered<512>(size, [&](u8* data, size_t data_size) { + auto result = buffer.write_buffered<512>(size, [&](Bytes data) { size_t bytes_written = 0; - for (; bytes_written < data_size; ++bytes_written) { + for (; bytes_written < data.size(); ++bytes_written) { auto bit_index = m_input_buffer.head_index(); bool is_special_character = m_special_character_bitmask[bit_index / 8] & (1 << (bit_index % 8)); if (in_canonical_mode() && is_special_character) { @@ -88,11 +88,11 @@ KResultOr TTY::write(FileDescription&, u64, const UserOrKernelBuffer& bu } constexpr size_t num_chars = 256; - return buffer.read_buffered(size, [&](u8 const* data, size_t buffer_bytes) -> KResultOr { + return buffer.read_buffered(size, [&](ReadonlyBytes bytes) -> KResultOr { u8 modified_data[num_chars * 2]; size_t modified_data_size = 0; - for (size_t i = 0; i < buffer_bytes; ++i) { - process_output(data[i], [&modified_data, &modified_data_size](u8 out_ch) { + for (const auto& byte : bytes) { + process_output(byte, [&modified_data, &modified_data_size](u8 out_ch) { modified_data[modified_data_size++] = out_ch; }); } @@ -101,14 +101,14 @@ KResultOr TTY::write(FileDescription&, u64, const UserOrKernelBuffer& bu return bytes_written_or_error; auto bytes_written = bytes_written_or_error.value(); if (bytes_written == modified_data_size) - return buffer_bytes; + return bytes.size(); // Degenerate case where we converted some newlines and encountered a partial write // Calculate where in the input buffer the last character would have been size_t pos_data = 0; for (size_t pos_modified_data = 0; pos_modified_data < bytes_written; ++pos_data) { - if (data[pos_data] == '\n') + if (bytes[pos_data] == '\n') pos_modified_data += 2; else pos_modified_data += 1; diff --git a/Kernel/TTY/VirtualConsole.cpp b/Kernel/TTY/VirtualConsole.cpp index 410fbe9117..aeddb9a5a7 100644 --- a/Kernel/TTY/VirtualConsole.cpp +++ b/Kernel/TTY/VirtualConsole.cpp @@ -260,10 +260,10 @@ void VirtualConsole::on_key_pressed(KeyEvent event) KResultOr VirtualConsole::on_tty_write(const UserOrKernelBuffer& data, size_t size) { SpinlockLocker global_lock(ConsoleManagement::the().tty_write_lock()); - auto result = data.read_buffered<512>(size, [&](u8 const* buffer, size_t buffer_bytes) { - for (size_t i = 0; i < buffer_bytes; ++i) - m_console_impl.on_input(buffer[i]); - return buffer_bytes; + auto result = data.read_buffered<512>(size, [&](ReadonlyBytes buffer) { + for (const auto& byte : buffer) + m_console_impl.on_input(byte); + return buffer.size(); }); if (m_active) flush_dirty_lines(); diff --git a/Kernel/UserOrKernelBuffer.h b/Kernel/UserOrKernelBuffer.h index 799d8df953..dfc11ee6c4 100644 --- a/Kernel/UserOrKernelBuffer.h +++ b/Kernel/UserOrKernelBuffer.h @@ -89,7 +89,8 @@ public: return EFAULT; if (is_kernel_buffer()) { // We're transferring directly to a kernel buffer, bypass - return f(m_buffer + offset, len); + Bytes bytes { m_buffer + offset, len }; + return f(bytes); } // The purpose of using a buffer on the stack is that we can @@ -98,7 +99,8 @@ public: size_t nwritten = 0; while (nwritten < len) { auto to_copy = min(sizeof(buffer), len - nwritten); - KResultOr copied_or_error = f(buffer, to_copy); + Bytes bytes { buffer, to_copy }; + KResultOr copied_or_error = f(bytes); if (copied_or_error.is_error()) return copied_or_error.error(); auto copied = copied_or_error.value(); @@ -124,7 +126,7 @@ public: return EFAULT; if (is_kernel_buffer()) { // We're transferring directly from a kernel buffer, bypass - return f(m_buffer + offset, len); + return f({ m_buffer + offset, len }); } // The purpose of using a buffer on the stack is that we can @@ -135,7 +137,8 @@ public: auto to_copy = min(sizeof(buffer), len - nread); if (!read(buffer, nread, to_copy)) return EFAULT; - KResultOr copied_or_error = f(buffer, to_copy); + ReadonlyBytes read_only_bytes { buffer, to_copy }; + KResultOr copied_or_error = f(read_only_bytes); if (copied_or_error.is_error()) return copied_or_error.error(); auto copied = copied_or_error.value();