mirror of
https://github.com/RGBCube/serenity
synced 2025-07-24 22:07:34 +00:00
Kernel: Make UserOrKernelBuffer R/W helpers return KResultOr<size_t>
This makes error propagation less cumbersome (and also exposed some places where we were not doing it.)
This commit is contained in:
parent
25a45e639a
commit
e46343bf9a
15 changed files with 64 additions and 85 deletions
|
@ -57,14 +57,11 @@ Kernel::KResultOr<size_t> Console::write(FileDescription&, u64, const Kernel::Us
|
||||||
if (!size)
|
if (!size)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
ssize_t nread = data.read_buffered<256>(size, [&](const u8* bytes, size_t bytes_count) {
|
return data.read_buffered<256>(size, [&](u8 const* bytes, size_t bytes_count) {
|
||||||
for (size_t i = 0; i < bytes_count; i++)
|
for (size_t i = 0; i < bytes_count; i++)
|
||||||
put_char((char)bytes[i]);
|
put_char((char)bytes[i]);
|
||||||
return (ssize_t)bytes_count;
|
return bytes_count;
|
||||||
});
|
});
|
||||||
if (nread < 0)
|
|
||||||
return Kernel::KResult((ErrnoCode)-nread);
|
|
||||||
return (size_t)nread;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Console::put_char(char ch)
|
void Console::put_char(char ch)
|
||||||
|
|
|
@ -90,7 +90,7 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
template<size_t BUFFER_BYTES, typename... Args>
|
template<size_t BUFFER_BYTES, typename... Args>
|
||||||
[[nodiscard]] bool write_to_buffer_buffered(UserOrKernelBuffer& buffer, Args... args)
|
[[nodiscard]] KResultOr<size_t> write_to_buffer_buffered(UserOrKernelBuffer& buffer, Args... args)
|
||||||
{
|
{
|
||||||
if (in_target_context(buffer))
|
if (in_target_context(buffer))
|
||||||
return buffer.write_buffered<BUFFER_BYTES>(forward<Args>(args)...);
|
return buffer.write_buffered<BUFFER_BYTES>(forward<Args>(args)...);
|
||||||
|
@ -108,7 +108,7 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
template<size_t BUFFER_BYTES, typename... Args>
|
template<size_t BUFFER_BYTES, typename... Args>
|
||||||
[[nodiscard]] bool read_from_buffer_buffered(const UserOrKernelBuffer& buffer, Args... args)
|
[[nodiscard]] KResultOr<size_t> read_from_buffer_buffered(const UserOrKernelBuffer& buffer, Args... args)
|
||||||
{
|
{
|
||||||
if (in_target_context(buffer))
|
if (in_target_context(buffer))
|
||||||
return buffer.read_buffered<BUFFER_BYTES>(forward<Args>(args)...);
|
return buffer.read_buffered<BUFFER_BYTES>(forward<Args>(args)...);
|
||||||
|
|
|
@ -298,13 +298,13 @@ KResultOr<size_t> KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer
|
||||||
|
|
||||||
lock.unlock();
|
lock.unlock();
|
||||||
|
|
||||||
ssize_t n = buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](u8* data, size_t data_bytes) {
|
auto result = buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](u8* data, size_t data_bytes) {
|
||||||
memcpy(data, &event, sizeof(Event));
|
memcpy(data, &event, sizeof(Event));
|
||||||
return (ssize_t)data_bytes;
|
return data_bytes;
|
||||||
});
|
});
|
||||||
if (n < 0)
|
if (result.is_error())
|
||||||
return KResult((ErrnoCode)-n);
|
return result.error();
|
||||||
VERIFY((size_t)n == sizeof(Event));
|
VERIFY(result.value() == sizeof(Event));
|
||||||
nread += sizeof(Event);
|
nread += sizeof(Event);
|
||||||
|
|
||||||
lock.lock();
|
lock.lock();
|
||||||
|
|
|
@ -25,13 +25,10 @@ bool RandomDevice::can_read(const FileDescription&, size_t) const
|
||||||
|
|
||||||
KResultOr<size_t> RandomDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
|
KResultOr<size_t> RandomDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
|
||||||
{
|
{
|
||||||
bool success = buffer.write_buffered<256>(size, [&](u8* data, size_t data_size) {
|
return buffer.write_buffered<256>(size, [&](u8* data, size_t data_size) {
|
||||||
get_good_random_bytes(data, data_size);
|
get_good_random_bytes(data, data_size);
|
||||||
return (ssize_t)data_size;
|
return data_size;
|
||||||
});
|
});
|
||||||
if (!success)
|
|
||||||
return EFAULT;
|
|
||||||
return size;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
KResultOr<size_t> RandomDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t size)
|
KResultOr<size_t> RandomDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t size)
|
||||||
|
|
|
@ -33,15 +33,11 @@ KResultOr<size_t> SerialDevice::read(FileDescription&, u64, UserOrKernelBuffer&
|
||||||
if (!(get_line_status() & DataReady))
|
if (!(get_line_status() & DataReady))
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
ssize_t nwritten = buffer.write_buffered<128>(size, [&](u8* data, size_t data_size) {
|
return buffer.write_buffered<128>(size, [&](u8* data, size_t data_size) {
|
||||||
for (size_t i = 0; i < data_size; i++)
|
for (size_t i = 0; i < data_size; i++)
|
||||||
data[i] = IO::in8(m_base_addr);
|
data[i] = IO::in8(m_base_addr);
|
||||||
return (ssize_t)data_size;
|
return data_size;
|
||||||
});
|
});
|
||||||
if (nwritten < 0)
|
|
||||||
return KResult((ErrnoCode)-nwritten);
|
|
||||||
|
|
||||||
return size;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool SerialDevice::can_write(const FileDescription&, size_t) const
|
bool SerialDevice::can_write(const FileDescription&, size_t) const
|
||||||
|
@ -57,14 +53,11 @@ KResultOr<size_t> SerialDevice::write(FileDescription&, u64, const UserOrKernelB
|
||||||
if (!(get_line_status() & EmptyTransmitterHoldingRegister))
|
if (!(get_line_status() & EmptyTransmitterHoldingRegister))
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
ssize_t nread = buffer.read_buffered<128>(size, [&](const u8* data, size_t data_size) {
|
return buffer.read_buffered<128>(size, [&](u8 const* data, size_t data_size) {
|
||||||
for (size_t i = 0; i < data_size; i++)
|
for (size_t i = 0; i < data_size; i++)
|
||||||
IO::out8(m_base_addr, data[i]);
|
IO::out8(m_base_addr, data[i]);
|
||||||
return (ssize_t)data_size;
|
return data_size;
|
||||||
});
|
});
|
||||||
if (nread < 0)
|
|
||||||
return KResult((ErrnoCode)-nread);
|
|
||||||
return (size_t)nread;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
String SerialDevice::device_name() const
|
String SerialDevice::device_name() const
|
||||||
|
|
|
@ -48,7 +48,7 @@ KResultOr<size_t> InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer&
|
||||||
if (buffer_size < bytes_to_write)
|
if (buffer_size < bytes_to_write)
|
||||||
return EINVAL;
|
return EINVAL;
|
||||||
|
|
||||||
ssize_t nwritten = 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, [&](u8* data, size_t data_bytes) {
|
||||||
size_t offset = 0;
|
size_t offset = 0;
|
||||||
|
|
||||||
memcpy(data + offset, &event.wd, sizeof(InodeWatcherEvent::watch_descriptor));
|
memcpy(data + offset, &event.wd, sizeof(InodeWatcherEvent::watch_descriptor));
|
||||||
|
@ -64,12 +64,10 @@ KResultOr<size_t> InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer&
|
||||||
memset(data + offset, 0, sizeof(InodeWatcherEvent::name_length));
|
memset(data + offset, 0, sizeof(InodeWatcherEvent::name_length));
|
||||||
}
|
}
|
||||||
|
|
||||||
return (ssize_t)data_bytes;
|
return data_bytes;
|
||||||
});
|
});
|
||||||
if (nwritten < 0)
|
|
||||||
return KResult((ErrnoCode)-nwritten);
|
|
||||||
evaluate_block_conditions();
|
evaluate_block_conditions();
|
||||||
return bytes_to_write;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
KResult InodeWatcher::close()
|
KResult InodeWatcher::close()
|
||||||
|
|
|
@ -903,17 +903,17 @@ static ssize_t write_sys_bool(InodeIdentifier inode_id, const UserOrKernelBuffer
|
||||||
|
|
||||||
char value = 0;
|
char value = 0;
|
||||||
bool did_read = false;
|
bool did_read = false;
|
||||||
ssize_t nread = buffer.read_buffered<1>(1, [&](const u8* data, size_t) {
|
auto result = buffer.read_buffered<1>(1, [&](u8 const* data, size_t) {
|
||||||
if (did_read)
|
if (did_read)
|
||||||
return 0;
|
return 0;
|
||||||
value = (char)data[0];
|
value = (char)data[0];
|
||||||
did_read = true;
|
did_read = true;
|
||||||
return 1;
|
return 1;
|
||||||
});
|
});
|
||||||
if (nread < 0)
|
if (result.is_error())
|
||||||
return nread;
|
return result.error();
|
||||||
VERIFY(nread == 0 || (nread == 1 && did_read));
|
VERIFY(result.value() == 0 || (result.value() == 1 && did_read));
|
||||||
if (nread == 0 || !(value == '0' || value == '1'))
|
if (result.value() == 0 || !(value == '0' || value == '1'))
|
||||||
return (ssize_t)size;
|
return (ssize_t)size;
|
||||||
|
|
||||||
auto* lockable_bool = reinterpret_cast<Lockable<bool>*>(variable.address);
|
auto* lockable_bool = reinterpret_cast<Lockable<bool>*>(variable.address);
|
||||||
|
|
|
@ -255,7 +255,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_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$inode_watcher_remove_watch(int fd, int wd);
|
||||||
KResultOr<int> sys$dbgputch(u8);
|
KResultOr<int> sys$dbgputch(u8);
|
||||||
KResultOr<int> sys$dbgputstr(Userspace<const u8*>, int length);
|
KResultOr<size_t> sys$dbgputstr(Userspace<const u8*>, int length);
|
||||||
KResultOr<int> sys$dump_backtrace();
|
KResultOr<int> sys$dump_backtrace();
|
||||||
KResultOr<pid_t> sys$gettid();
|
KResultOr<pid_t> sys$gettid();
|
||||||
KResultOr<int> sys$donate(pid_t tid);
|
KResultOr<int> sys$donate(pid_t tid);
|
||||||
|
@ -372,7 +372,7 @@ public:
|
||||||
KResultOr<int> sys$halt();
|
KResultOr<int> sys$halt();
|
||||||
KResultOr<int> sys$reboot();
|
KResultOr<int> sys$reboot();
|
||||||
KResultOr<int> sys$realpath(Userspace<const Syscall::SC_realpath_params*>);
|
KResultOr<int> sys$realpath(Userspace<const Syscall::SC_realpath_params*>);
|
||||||
KResultOr<ssize_t> sys$getrandom(Userspace<void*>, size_t, unsigned int);
|
KResultOr<size_t> sys$getrandom(Userspace<void*>, size_t, unsigned int);
|
||||||
KResultOr<int> sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*>);
|
KResultOr<int> sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*>);
|
||||||
KResultOr<int> sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*>);
|
KResultOr<int> sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*>);
|
||||||
KResultOr<int> sys$module_load(Userspace<const char*> path, size_t path_length);
|
KResultOr<int> sys$module_load(Userspace<const char*> path, size_t path_length);
|
||||||
|
|
|
@ -476,12 +476,12 @@ bool IDEChannel::ata_do_read_sector()
|
||||||
dbgln_if(PATA_DEBUG, "IDEChannel::ata_do_read_sector");
|
dbgln_if(PATA_DEBUG, "IDEChannel::ata_do_read_sector");
|
||||||
auto& request = *m_current_request;
|
auto& request = *m_current_request;
|
||||||
auto out_buffer = request.buffer().offset(m_current_request_block_index * 512);
|
auto out_buffer = request.buffer().offset(m_current_request_block_index * 512);
|
||||||
ssize_t nwritten = request.write_to_buffer_buffered<512>(out_buffer, 512, [&](u8* buffer, size_t buffer_bytes) {
|
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))
|
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());
|
*(u16*)&buffer[i] = IO::in16(m_io_group.io_base().offset(ATA_REG_DATA).get());
|
||||||
return (ssize_t)buffer_bytes;
|
return buffer_bytes;
|
||||||
});
|
});
|
||||||
if (nwritten < 0) {
|
if (result.is_error()) {
|
||||||
// TODO: Do we need to abort the PATA read if this wasn't the last block?
|
// TODO: Do we need to abort the PATA read if this wasn't the last block?
|
||||||
complete_current_request(AsyncDeviceRequest::MemoryFault);
|
complete_current_request(AsyncDeviceRequest::MemoryFault);
|
||||||
return false;
|
return false;
|
||||||
|
@ -518,12 +518,12 @@ void IDEChannel::ata_do_write_sector()
|
||||||
|
|
||||||
auto in_buffer = request.buffer().offset(m_current_request_block_index * 512);
|
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);
|
dbgln_if(PATA_DEBUG, "IDEChannel: Writing 512 bytes (part {}) (status={:#02x})...", m_current_request_block_index, status);
|
||||||
ssize_t nread = request.read_from_buffer_buffered<512>(in_buffer, 512, [&](const u8* buffer, size_t buffer_bytes) {
|
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))
|
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]);
|
IO::out16(m_io_group.io_base().offset(ATA_REG_DATA).get(), *(const u16*)&buffer[i]);
|
||||||
return (ssize_t)buffer_bytes;
|
return buffer_bytes;
|
||||||
});
|
});
|
||||||
if (nread < 0)
|
if (result.is_error())
|
||||||
complete_current_request(AsyncDeviceRequest::MemoryFault);
|
complete_current_request(AsyncDeviceRequest::MemoryFault);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -23,7 +23,7 @@ KResultOr<int> Process::sys$dbgputch(u8 ch)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
KResultOr<int> Process::sys$dbgputstr(Userspace<const u8*> characters, int length)
|
KResultOr<size_t> Process::sys$dbgputstr(Userspace<const u8*> characters, int length)
|
||||||
{
|
{
|
||||||
if (length <= 0)
|
if (length <= 0)
|
||||||
return 0;
|
return 0;
|
||||||
|
@ -31,14 +31,11 @@ KResultOr<int> Process::sys$dbgputstr(Userspace<const u8*> characters, int lengt
|
||||||
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, length);
|
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, length);
|
||||||
if (!buffer.has_value())
|
if (!buffer.has_value())
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
ssize_t nread = buffer.value().read_buffered<1024>(length, [&](const u8* buffer, size_t buffer_size) {
|
return buffer.value().read_buffered<1024>(length, [&](u8 const* buffer, size_t buffer_size) {
|
||||||
for (size_t i = 0; i < buffer_size; ++i)
|
for (size_t i = 0; i < buffer_size; ++i)
|
||||||
IO::out8(0xe9, buffer[i]);
|
IO::out8(0xe9, buffer[i]);
|
||||||
return (ssize_t)buffer_size;
|
return buffer_size;
|
||||||
});
|
});
|
||||||
if (nread < 0)
|
|
||||||
return (int)nread;
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
|
@ -13,7 +13,7 @@ namespace Kernel {
|
||||||
// We don't use the flag yet, but we could use it for distinguishing
|
// We don't use the flag yet, but we could use it for distinguishing
|
||||||
// random source like Linux, unlike the OpenBSD equivalent. However, if we
|
// random source like Linux, unlike the OpenBSD equivalent. However, if we
|
||||||
// do, we should be able of the caveats that Linux has dealt with.
|
// do, we should be able of the caveats that Linux has dealt with.
|
||||||
KResultOr<ssize_t> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
|
KResultOr<size_t> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
|
||||||
{
|
{
|
||||||
REQUIRE_PROMISE(stdio);
|
REQUIRE_PROMISE(stdio);
|
||||||
if (buffer_size <= 0)
|
if (buffer_size <= 0)
|
||||||
|
@ -22,11 +22,10 @@ KResultOr<ssize_t> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer
|
||||||
auto data_buffer = UserOrKernelBuffer::for_user_buffer(buffer, buffer_size);
|
auto data_buffer = UserOrKernelBuffer::for_user_buffer(buffer, buffer_size);
|
||||||
if (!data_buffer.has_value())
|
if (!data_buffer.has_value())
|
||||||
return EFAULT;
|
return EFAULT;
|
||||||
ssize_t nwritten = data_buffer.value().write_buffered<1024>(buffer_size, [&](u8* buffer, size_t buffer_bytes) {
|
return data_buffer.value().write_buffered<1024>(buffer_size, [&](u8* buffer, size_t buffer_bytes) {
|
||||||
get_good_random_bytes(buffer, buffer_bytes);
|
get_good_random_bytes(buffer, buffer_bytes);
|
||||||
return (ssize_t)buffer_bytes;
|
return buffer_bytes;
|
||||||
});
|
});
|
||||||
return nwritten;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
|
@ -46,12 +46,12 @@ void SlavePTY::echo(u8 ch)
|
||||||
|
|
||||||
void SlavePTY::on_master_write(const UserOrKernelBuffer& buffer, ssize_t size)
|
void SlavePTY::on_master_write(const UserOrKernelBuffer& buffer, ssize_t size)
|
||||||
{
|
{
|
||||||
ssize_t nread = buffer.read_buffered<128>(size, [&](const u8* data, size_t data_size) {
|
auto result = buffer.read_buffered<128>(size, [&](u8 const* data, size_t data_size) {
|
||||||
for (size_t i = 0; i < data_size; ++i)
|
for (size_t i = 0; i < data_size; ++i)
|
||||||
emit(data[i], false);
|
emit(data[i], false);
|
||||||
return (ssize_t)data_size;
|
return data_size;
|
||||||
});
|
});
|
||||||
if (nread > 0)
|
if (!result.is_error())
|
||||||
evaluate_block_conditions();
|
evaluate_block_conditions();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -43,10 +43,10 @@ KResultOr<size_t> TTY::read(FileDescription&, u64, UserOrKernelBuffer& buffer, s
|
||||||
if (m_input_buffer.size() < static_cast<size_t>(size))
|
if (m_input_buffer.size() < static_cast<size_t>(size))
|
||||||
size = m_input_buffer.size();
|
size = m_input_buffer.size();
|
||||||
|
|
||||||
ssize_t nwritten;
|
KResultOr<size_t> result = 0;
|
||||||
bool need_evaluate_block_conditions = false;
|
bool need_evaluate_block_conditions = false;
|
||||||
if (in_canonical_mode()) {
|
if (in_canonical_mode()) {
|
||||||
nwritten = buffer.write_buffered<512>(size, [&](u8* data, size_t data_size) {
|
result = buffer.write_buffered<512>(size, [&](u8* data, size_t data_size) {
|
||||||
size_t i = 0;
|
size_t i = 0;
|
||||||
for (; i < data_size; i++) {
|
for (; i < data_size; i++) {
|
||||||
u8 ch = m_input_buffer.dequeue();
|
u8 ch = m_input_buffer.dequeue();
|
||||||
|
@ -64,10 +64,10 @@ KResultOr<size_t> TTY::read(FileDescription&, u64, UserOrKernelBuffer& buffer, s
|
||||||
}
|
}
|
||||||
data[i] = ch;
|
data[i] = ch;
|
||||||
}
|
}
|
||||||
return (ssize_t)i;
|
return i;
|
||||||
});
|
});
|
||||||
} else {
|
} else {
|
||||||
nwritten = buffer.write_buffered<512>(size, [&](u8* data, size_t data_size) {
|
result = buffer.write_buffered<512>(size, [&](u8* data, size_t data_size) {
|
||||||
for (size_t i = 0; i < data_size; i++) {
|
for (size_t i = 0; i < data_size; i++) {
|
||||||
auto ch = m_input_buffer.dequeue();
|
auto ch = m_input_buffer.dequeue();
|
||||||
if (ch == '\r' && m_termios.c_iflag & ICRNL)
|
if (ch == '\r' && m_termios.c_iflag & ICRNL)
|
||||||
|
@ -76,14 +76,12 @@ KResultOr<size_t> TTY::read(FileDescription&, u64, UserOrKernelBuffer& buffer, s
|
||||||
ch = '\r';
|
ch = '\r';
|
||||||
data[i] = ch;
|
data[i] = ch;
|
||||||
}
|
}
|
||||||
return (ssize_t)data_size;
|
return data_size;
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
if (nwritten < 0)
|
if ((!result.is_error() && result.value() > 0) || need_evaluate_block_conditions)
|
||||||
return KResult((ErrnoCode)-nwritten);
|
|
||||||
if (nwritten > 0 || need_evaluate_block_conditions)
|
|
||||||
evaluate_block_conditions();
|
evaluate_block_conditions();
|
||||||
return (size_t)nwritten;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
KResultOr<size_t> TTY::write(FileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
|
KResultOr<size_t> TTY::write(FileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
|
||||||
|
@ -93,8 +91,8 @@ KResultOr<size_t> TTY::write(FileDescription&, u64, const UserOrKernelBuffer& bu
|
||||||
return EINTR;
|
return EINTR;
|
||||||
}
|
}
|
||||||
|
|
||||||
const size_t num_chars = 256;
|
constexpr size_t num_chars = 256;
|
||||||
ssize_t nread = buffer.read_buffered<num_chars>((size_t)size, [&](const u8* data, size_t buffer_bytes) {
|
return buffer.read_buffered<num_chars>(size, [&](u8 const* data, size_t buffer_bytes) {
|
||||||
u8 modified_data[num_chars * 2];
|
u8 modified_data[num_chars * 2];
|
||||||
size_t extra_chars = 0;
|
size_t extra_chars = 0;
|
||||||
for (size_t i = 0; i < buffer_bytes; ++i) {
|
for (size_t i = 0; i < buffer_bytes; ++i) {
|
||||||
|
@ -106,10 +104,8 @@ KResultOr<size_t> TTY::write(FileDescription&, u64, const UserOrKernelBuffer& bu
|
||||||
modified_data[i + extra_chars] = ch;
|
modified_data[i + extra_chars] = ch;
|
||||||
}
|
}
|
||||||
on_tty_write(UserOrKernelBuffer::for_kernel_buffer(modified_data), buffer_bytes + extra_chars);
|
on_tty_write(UserOrKernelBuffer::for_kernel_buffer(modified_data), buffer_bytes + extra_chars);
|
||||||
return (ssize_t)buffer_bytes;
|
return buffer_bytes;
|
||||||
});
|
});
|
||||||
|
|
||||||
return nread;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool TTY::can_read(const FileDescription&, size_t) const
|
bool TTY::can_read(const FileDescription&, size_t) const
|
||||||
|
|
|
@ -226,14 +226,16 @@ void VirtualConsole::on_key_pressed(KeyEvent event)
|
||||||
ssize_t VirtualConsole::on_tty_write(const UserOrKernelBuffer& data, ssize_t size)
|
ssize_t VirtualConsole::on_tty_write(const UserOrKernelBuffer& data, ssize_t size)
|
||||||
{
|
{
|
||||||
ScopedSpinLock lock(s_lock);
|
ScopedSpinLock lock(s_lock);
|
||||||
ssize_t nread = data.read_buffered<512>((size_t)size, [&](const u8* buffer, size_t buffer_bytes) {
|
auto result = data.read_buffered<512>((size_t)size, [&](u8 const* buffer, size_t buffer_bytes) {
|
||||||
for (size_t i = 0; i < buffer_bytes; ++i)
|
for (size_t i = 0; i < buffer_bytes; ++i)
|
||||||
m_terminal.on_input(buffer[i]);
|
m_terminal.on_input(buffer[i]);
|
||||||
return (ssize_t)buffer_bytes;
|
return buffer_bytes;
|
||||||
});
|
});
|
||||||
if (m_active)
|
if (m_active)
|
||||||
flush_dirty_lines();
|
flush_dirty_lines();
|
||||||
return nread;
|
if (result.is_error())
|
||||||
|
return result.error();
|
||||||
|
return (ssize_t)result.value();
|
||||||
}
|
}
|
||||||
|
|
||||||
void VirtualConsole::set_vga_start_row(u16 row)
|
void VirtualConsole::set_vga_start_row(u16 row)
|
||||||
|
|
|
@ -82,10 +82,10 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
template<size_t BUFFER_BYTES, typename F>
|
template<size_t BUFFER_BYTES, typename F>
|
||||||
[[nodiscard]] ssize_t write_buffered(size_t offset, size_t len, F f)
|
[[nodiscard]] KResultOr<size_t> write_buffered(size_t offset, size_t len, F f)
|
||||||
{
|
{
|
||||||
if (!m_buffer)
|
if (!m_buffer)
|
||||||
return -EFAULT;
|
return EFAULT;
|
||||||
if (is_kernel_buffer()) {
|
if (is_kernel_buffer()) {
|
||||||
// We're transferring directly to a kernel buffer, bypass
|
// We're transferring directly to a kernel buffer, bypass
|
||||||
return f(m_buffer + offset, len);
|
return f(m_buffer + offset, len);
|
||||||
|
@ -102,24 +102,24 @@ public:
|
||||||
return copied;
|
return copied;
|
||||||
VERIFY((size_t)copied <= to_copy);
|
VERIFY((size_t)copied <= to_copy);
|
||||||
if (!write(buffer, nwritten, (size_t)copied))
|
if (!write(buffer, nwritten, (size_t)copied))
|
||||||
return -EFAULT;
|
return EFAULT;
|
||||||
nwritten += (size_t)copied;
|
nwritten += (size_t)copied;
|
||||||
if ((size_t)copied < to_copy)
|
if ((size_t)copied < to_copy)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
return (ssize_t)nwritten;
|
return nwritten;
|
||||||
}
|
}
|
||||||
template<size_t BUFFER_BYTES, typename F>
|
template<size_t BUFFER_BYTES, typename F>
|
||||||
[[nodiscard]] ssize_t write_buffered(size_t len, F f)
|
[[nodiscard]] KResultOr<size_t> write_buffered(size_t len, F f)
|
||||||
{
|
{
|
||||||
return write_buffered<BUFFER_BYTES, F>(0, len, f);
|
return write_buffered<BUFFER_BYTES, F>(0, len, f);
|
||||||
}
|
}
|
||||||
|
|
||||||
template<size_t BUFFER_BYTES, typename F>
|
template<size_t BUFFER_BYTES, typename F>
|
||||||
[[nodiscard]] ssize_t read_buffered(size_t offset, size_t len, F f) const
|
[[nodiscard]] KResultOr<size_t> read_buffered(size_t offset, size_t len, F f) const
|
||||||
{
|
{
|
||||||
if (!m_buffer)
|
if (!m_buffer)
|
||||||
return -EFAULT;
|
return EFAULT;
|
||||||
if (is_kernel_buffer()) {
|
if (is_kernel_buffer()) {
|
||||||
// We're transferring directly from a kernel buffer, bypass
|
// We're transferring directly from a kernel buffer, bypass
|
||||||
return f(m_buffer + offset, len);
|
return f(m_buffer + offset, len);
|
||||||
|
@ -132,7 +132,7 @@ public:
|
||||||
while (nread < len) {
|
while (nread < len) {
|
||||||
auto to_copy = min(sizeof(buffer), len - nread);
|
auto to_copy = min(sizeof(buffer), len - nread);
|
||||||
if (!read(buffer, nread, to_copy))
|
if (!read(buffer, nread, to_copy))
|
||||||
return -EFAULT;
|
return EFAULT;
|
||||||
ssize_t copied = f(buffer, to_copy);
|
ssize_t copied = f(buffer, to_copy);
|
||||||
if (copied < 0)
|
if (copied < 0)
|
||||||
return copied;
|
return copied;
|
||||||
|
@ -144,7 +144,7 @@ public:
|
||||||
return nread;
|
return nread;
|
||||||
}
|
}
|
||||||
template<size_t BUFFER_BYTES, typename F>
|
template<size_t BUFFER_BYTES, typename F>
|
||||||
[[nodiscard]] ssize_t read_buffered(size_t len, F f) const
|
[[nodiscard]] KResultOr<size_t> read_buffered(size_t len, F f) const
|
||||||
{
|
{
|
||||||
return read_buffered<BUFFER_BYTES, F>(0, len, f);
|
return read_buffered<BUFFER_BYTES, F>(0, len, f);
|
||||||
}
|
}
|
||||||
|
|
Loading…
Add table
Add a link
Reference in a new issue