RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 00:57:36 +00:00
Code Issues Activity Actions

Kernel: Convert UserOrKernelBuffer callbacks to use AK::Bytes

Browse source
This commit is contained in:
Brian Gianforcaro 2021-08-31 23:44:55 -07:00 • committed by Andreas Kling
parent f3baa5d8c9
commit 668c429900
11 changed files with 58 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Kernel/ConsoleDevice.cpp
View file

@ -58,10 +58,10 @@ Kernel::KResultOr<size_t> 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();
});
}

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

@ -292,9 +292,9 @@ KResultOr<size_t> KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer
lock.unlock();
auto result = buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](u8* data, size_t data_bytes) {
memcpy(data, &event, sizeof(Event));
return data_bytes;
auto result = buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](Bytes bytes) {
memcpy(bytes.data(), &event, sizeof(Event));
return bytes.size();
});
if (result.is_error())
return result.error();

6
Kernel/Devices/RandomDevice.cpp
View file

@ -31,9 +31,9 @@ bool RandomDevice::can_read(const FileDescription&, size_t) const
KResultOr<size_t> 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();
});
}

16
Kernel/Devices/SerialDevice.cpp
View file

@ -63,10 +63,10 @@ KResultOr<size_t> 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<u8>();
return data_size;
return buffer.write_buffered<128>(size, [&](Bytes bytes) {
for (auto& byte : bytes)
byte = m_base_addr.in<u8>();
return bytes.size();
});
}
@ -84,10 +84,10 @@ KResultOr<size_t> 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();
});
}

14
Kernel/FileSystem/InodeWatcher.cpp
View file

@ -48,23 +48,23 @@ KResultOr<size_t> InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer&
if (buffer_size < bytes_to_write)
return EINVAL;
auto result = buffer.write_buffered<MAXIMUM_EVENT_SIZE>(bytes_to_write, [&](u8* data, size_t data_bytes) {
auto result = buffer.write_buffered<MAXIMUM_EVENT_SIZE>(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;

16
Kernel/Storage/IDEChannel.cpp
View file

@ -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);

6
Kernel/Syscalls/getrandom.cpp
View file

@ -23,9 +23,9 @@ KResultOr<FlatPtr> Process::sys$getrandom(Userspace<void*> 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();

8
Kernel/TTY/SlavePTY.cpp
View file

@ -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();

14
Kernel/TTY/TTY.cpp
View file

@ -52,9 +52,9 @@ KResultOr<size_t> 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<size_t> TTY::write(FileDescription&, u64, const UserOrKernelBuffer& bu
}
constexpr size_t num_chars = 256;
return buffer.read_buffered<num_chars>(size, [&](u8 const* data, size_t buffer_bytes) -> KResultOr<size_t> {
return buffer.read_buffered<num_chars>(size, [&](ReadonlyBytes bytes) -> KResultOr<size_t> {
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<size_t> 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;

8
Kernel/TTY/VirtualConsole.cpp
View file

@ -260,10 +260,10 @@ void VirtualConsole::on_key_pressed(KeyEvent event)
KResultOr<size_t> 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();

11
Kernel/UserOrKernelBuffer.h
View file

@ -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<size_t> copied_or_error = f(buffer, to_copy);
Bytes bytes { buffer, to_copy };
KResultOr<size_t> 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<size_t> copied_or_error = f(buffer, 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())
return copied_or_error.error();
auto copied = copied_or_error.value();