mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-10 13:00:29 +03:00
9201a06027
Before we start disabling acquisition of the big process lock for specific syscalls, make sure to document and assert that all the lock is held during all syscalls.
123 lines
3.7 KiB
C++
123 lines
3.7 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/NumericLimits.h>
|
|
#include <Kernel/Debug.h>
|
|
#include <Kernel/FileSystem/FileDescription.h>
|
|
#include <Kernel/Process.h>
|
|
|
|
namespace Kernel {
|
|
|
|
KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
REQUIRE_PROMISE(stdio);
|
|
if (iov_count < 0)
|
|
return EINVAL;
|
|
|
|
// Arbitrary pain threshold.
|
|
if (iov_count > (int)MiB)
|
|
return EFAULT;
|
|
|
|
u64 total_length = 0;
|
|
Vector<iovec, 32> vecs;
|
|
if (!vecs.try_resize(iov_count))
|
|
return ENOMEM;
|
|
if (!copy_n_from_user(vecs.data(), iov, iov_count))
|
|
return EFAULT;
|
|
for (auto& vec : vecs) {
|
|
total_length += vec.iov_len;
|
|
if (total_length > NumericLimits<i32>::max())
|
|
return EINVAL;
|
|
}
|
|
|
|
auto description = fds().file_description(fd);
|
|
if (!description)
|
|
return EBADF;
|
|
|
|
if (!description->is_writable())
|
|
return EBADF;
|
|
|
|
int nwritten = 0;
|
|
for (auto& vec : vecs) {
|
|
auto buffer = UserOrKernelBuffer::for_user_buffer((u8*)vec.iov_base, vec.iov_len);
|
|
if (!buffer.has_value())
|
|
return EFAULT;
|
|
auto result = do_write(*description, buffer.value(), vec.iov_len);
|
|
if (result.is_error()) {
|
|
if (nwritten == 0)
|
|
return result.error();
|
|
return nwritten;
|
|
}
|
|
nwritten += result.value();
|
|
}
|
|
|
|
return nwritten;
|
|
}
|
|
|
|
KResultOr<FlatPtr> Process::do_write(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
|
|
{
|
|
size_t total_nwritten = 0;
|
|
|
|
if (description.should_append() && description.file().is_seekable()) {
|
|
auto seek_result = description.seek(0, SEEK_END);
|
|
if (seek_result.is_error())
|
|
return seek_result.error();
|
|
}
|
|
|
|
while (total_nwritten < data_size) {
|
|
while (!description.can_write()) {
|
|
if (!description.is_blocking()) {
|
|
if (total_nwritten > 0)
|
|
return total_nwritten;
|
|
else
|
|
return EAGAIN;
|
|
}
|
|
auto unblock_flags = Thread::FileBlocker::BlockFlags::None;
|
|
if (Thread::current()->block<Thread::WriteBlocker>({}, description, unblock_flags).was_interrupted()) {
|
|
if (total_nwritten == 0)
|
|
return EINTR;
|
|
}
|
|
// TODO: handle exceptions in unblock_flags
|
|
}
|
|
auto nwritten_or_error = description.write(data.offset(total_nwritten), data_size - total_nwritten);
|
|
if (nwritten_or_error.is_error()) {
|
|
if (total_nwritten > 0)
|
|
return total_nwritten;
|
|
if (nwritten_or_error.error() == EAGAIN)
|
|
continue;
|
|
return nwritten_or_error.error();
|
|
}
|
|
VERIFY(nwritten_or_error.value() > 0);
|
|
total_nwritten += nwritten_or_error.value();
|
|
}
|
|
return total_nwritten;
|
|
}
|
|
|
|
KResultOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
REQUIRE_PROMISE(stdio);
|
|
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 = fds().file_description(fd);
|
|
if (!description)
|
|
return EBADF;
|
|
if (!description->is_writable())
|
|
return EBADF;
|
|
|
|
auto buffer = UserOrKernelBuffer::for_user_buffer(data, static_cast<size_t>(size));
|
|
if (!buffer.has_value())
|
|
return EFAULT;
|
|
return do_write(*description, buffer.value(), size);
|
|
}
|
|
|
|
}
|