RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 05:07:35 +00:00
Code Issues Activity Actions

Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T>

Browse source 
We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace!
This was a slightly tedious refactoring that took a long time, so it's
not unlikely that some bugs crept in.

Nevertheless, it does pass basic functionality testing, and it's just
real nice to finally see the same pattern in all contexts. :^)
This commit is contained in:
Andreas Kling 2021-11-08 00:51:39 +01:00
parent 7ee10c6926
commit 79fa9765ca
262 changed files with 2415 additions and 2600 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Kernel/Syscalls/access.cpp
View file

@ -10,12 +10,13 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
ErrorOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath);
auto path = TRY(get_syscall_path_argument(user_path, path_length));
return VirtualFileSystem::the().access(path->view(), mode, current_directory());
TRY(VirtualFileSystem::the().access(path->view(), mode, current_directory()));
return 0;
}
}

2
Kernel/Syscalls/alarm.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$alarm(unsigned seconds)
ErrorOr<FlatPtr> Process::sys$alarm(unsigned seconds)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/anon_create.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$anon_create(size_t size, int options)
ErrorOr<FlatPtr> Process::sys$anon_create(size_t size, int options)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/beep.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$beep()
ErrorOr<FlatPtr> Process::sys$beep()
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
PCSpeaker::tone_on(440);

6
Kernel/Syscalls/chdir.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath);
@ -19,7 +19,7 @@ KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t p
return 0;
}
KResultOr<FlatPtr> Process::sys$fchdir(int fd)
ErrorOr<FlatPtr> Process::sys$fchdir(int fd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);
@ -32,7 +32,7 @@ KResultOr<FlatPtr> Process::sys$fchdir(int fd)
return 0;
}
KResultOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
ErrorOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath);

10
Kernel/Syscalls/chmod.cpp
View file

@ -10,20 +10,22 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t path_length, mode_t mode)
ErrorOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t path_length, mode_t mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(fattr);
auto path = TRY(get_syscall_path_argument(user_path, path_length));
return VirtualFileSystem::the().chmod(path->view(), mode, current_directory());
TRY(VirtualFileSystem::the().chmod(path->view(), mode, current_directory()));
return 0;
}
KResultOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode)
ErrorOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(fattr);
auto description = TRY(fds().open_file_description(fd));
return description->chmod(mode);
TRY(description->chmod(mode));
return 0;
}
}

11
Kernel/Syscalls/chown.cpp
View file

@ -9,22 +9,23 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$fchown(int fd, UserID uid, GroupID gid)
ErrorOr<FlatPtr> Process::sys$fchown(int fd, UserID uid, GroupID gid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(chown);
auto description = TRY(fds().open_file_description(fd));
return description->chown(uid, gid);
TRY(description->chown(uid, gid));
return 0;
}
KResultOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
ErrorOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(chown);
auto params = TRY(copy_typed_from_user(user_params));
auto path = TRY(get_syscall_path_argument(params.path));
return VirtualFileSystem::the().chown(path->view(), params.uid, params.gid, current_directory());
TRY(VirtualFileSystem::the().chown(path->view(), params.uid, params.gid, current_directory()));
return 0;
}
}

13
Kernel/Syscalls/clock.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$map_time_page()
ErrorOr<FlatPtr> Process::sys$map_time_page()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);
@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$map_time_page()
return region->vaddr().get();
}
KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts)
ErrorOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
REQUIRE_PROMISE(stdio);
@ -31,10 +31,11 @@ KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<time
return EINVAL;
auto ts = TimeManagement::the().current_time(clock_id).to_timespec();
return copy_to_user(user_ts, &ts);
TRY(copy_to_user(user_ts, &ts));
return 0;
}
KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts)
ErrorOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(settime);
@ -54,7 +55,7 @@ KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<cons
return 0;
}
KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
REQUIRE_PROMISE(stdio);
@ -93,7 +94,7 @@ KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_cloc
return 0;
}
KResultOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
ErrorOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
if (user_old_delta) {

6
Kernel/Syscalls/debug.cpp
View file

@ -11,21 +11,21 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$dump_backtrace()
ErrorOr<FlatPtr> Process::sys$dump_backtrace()
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
dump_backtrace();
return 0;
}
KResultOr<FlatPtr> Process::sys$dbgputch(u8 ch)
ErrorOr<FlatPtr> Process::sys$dbgputch(u8 ch)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
dbgputch(ch);
return 0;
}
KResultOr<FlatPtr> Process::sys$dbgputstr(Userspace<const char*> characters, size_t size)
ErrorOr<FlatPtr> Process::sys$dbgputstr(Userspace<const char*> characters, size_t size)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
if (size == 0)

2
Kernel/Syscalls/disown.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$disown(ProcessID pid)
ErrorOr<FlatPtr> Process::sys$disown(ProcessID pid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(proc);

2
Kernel/Syscalls/dup2.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd)
ErrorOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/emuctl.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$emuctl()
ErrorOr<FlatPtr> Process::sys$emuctl()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
return ENOSYS;

72
Kernel/Syscalls/execve.cpp
View file

@ -68,7 +68,7 @@ static bool validate_stack_size(NonnullOwnPtrVector<KString> const& arguments, N
return true;
}
static KResultOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]] ThreadRegisters& regs, Memory::Region& region, NonnullOwnPtrVector<KString> const& arguments,
static ErrorOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]] ThreadRegisters& regs, Memory::Region& region, NonnullOwnPtrVector<KString> const& arguments,
NonnullOwnPtrVector<KString> const& environment, Vector<ELF::AuxiliaryValue> auxiliary_values)
{
FlatPtr new_sp = region.range().end().get();
@ -80,21 +80,21 @@ static KResultOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]
new_sp -= sizeof(FlatPtr);
Userspace<FlatPtr*> stack_ptr = new_sp;
auto result = copy_to_user(stack_ptr, &value);
VERIFY(result.is_success());
VERIFY(!result.is_error());
};
auto push_aux_value_on_new_stack = [&new_sp](auxv_t value) {
new_sp -= sizeof(auxv_t);
Userspace<auxv_t*> stack_ptr = new_sp;
auto result = copy_to_user(stack_ptr, &value);
VERIFY(result.is_success());
VERIFY(!result.is_error());
};
auto push_string_on_new_stack = [&new_sp](StringView string) {
new_sp -= round_up_to_power_of_two(string.length() + 1, sizeof(FlatPtr));
Userspace<FlatPtr*> stack_ptr = new_sp;
auto result = copy_to_user(stack_ptr, string.characters_without_null_termination(), string.length() + 1);
VERIFY(result.is_success());
VERIFY(!result.is_error());
};
Vector<FlatPtr> argv_entries;
@ -162,7 +162,7 @@ struct RequiredLoadRange {
FlatPtr end { 0 };
};
static KResultOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& program_description)
static ErrorOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& program_description)
{
auto& inode = *(program_description.inode());
auto vmobject = TRY(Memory::SharedInodeVMObject::try_create_with_inode(inode));
@ -192,7 +192,7 @@ static KResultOr<RequiredLoadRange> get_required_load_range(OpenFileDescription&
return range;
};
static KResultOr<FlatPtr> get_load_offset(const ElfW(Ehdr) & main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
static ErrorOr<FlatPtr> get_load_offset(const ElfW(Ehdr) & main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
{
constexpr FlatPtr load_range_start = 0x08000000;
constexpr FlatPtr load_range_size = 65536 * PAGE_SIZE; // 2**16 * PAGE_SIZE = 256MB
@ -251,7 +251,7 @@ enum class ShouldAllowSyscalls {
Yes,
};
static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace> new_space, OpenFileDescription& object_description,
static ErrorOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace> new_space, OpenFileDescription& object_description,
FlatPtr load_offset, ShouldAllocateTls should_allocate_tls, ShouldAllowSyscalls should_allow_syscalls)
{
auto& inode = *(object_description.inode());
@ -280,7 +280,7 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
Memory::MemoryManager::enter_address_space(*new_space);
auto load_tls_section = [&](auto& program_header) -> KResult {
auto load_tls_section = [&](auto& program_header) -> ErrorOr<void> {
VERIFY(should_allocate_tls == ShouldAllocateTls::Yes);
VERIFY(program_header.size_in_memory());
@ -295,10 +295,10 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
master_tls_alignment = program_header.alignment();
TRY(copy_to_user(master_tls_region->vaddr().as_ptr(), program_header.raw_data(), program_header.size_in_image()));
return KSuccess;
return {};
};
auto load_writable_section = [&](auto& program_header) -> KResult {
auto load_writable_section = [&](auto& program_header) -> ErrorOr<void> {
// Writable section: create a copy in memory.
VERIFY(program_header.alignment() == PAGE_SIZE);
@ -330,12 +330,12 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
auto page_offset = program_header.vaddr();
page_offset.mask(~PAGE_MASK);
TRY(copy_to_user((u8*)region->vaddr().as_ptr() + page_offset.get(), program_header.raw_data(), program_header.size_in_image()));
return KSuccess;
return {};
};
auto load_section = [&](auto& program_header) -> KResult {
auto load_section = [&](auto& program_header) -> ErrorOr<void> {
if (program_header.size_in_memory() == 0)
return KSuccess;
return {};
if (program_header.is_writable())
return load_writable_section(program_header);
@ -359,10 +359,10 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
region->set_syscall_region(true);
if (program_header.offset() == 0)
load_base_address = (FlatPtr)region->vaddr().as_ptr();
return KSuccess;
return {};
};
auto load_elf_program_header = [&](auto& program_header) -> KResult {
auto load_elf_program_header = [&](auto& program_header) -> ErrorOr<void> {
if (program_header.type() == PT_TLS)
return load_tls_section(program_header);
@ -370,11 +370,11 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
return load_section(program_header);
// NOTE: We ignore other program header types.
return KSuccess;
return {};
};
TRY([&] {
KResult result = KSuccess;
ErrorOr<void> result;
elf_image.for_each_program_header([&](ELF::Image::ProgramHeader const& program_header) {
result = load_elf_program_header(program_header);
return result.is_error() ? IterationDecision::Break : IterationDecision::Continue;
@ -403,7 +403,7 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
};
}
KResultOr<LoadResult>
ErrorOr<LoadResult>
Process::load(NonnullRefPtr<OpenFileDescription> main_program_description,
RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header)
{
@ -433,7 +433,7 @@ Process::load(NonnullRefPtr<OpenFileDescription> main_program_description,
return interpreter_load_result;
}
KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment,
ErrorOr<void> Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment,
RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header)
{
VERIFY(is_user_process());
@ -555,10 +555,7 @@ KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_descrip
// NOTE: We create the new stack before disabling interrupts since it will zero-fault
// and we don't want to deal with faults after this point.
auto make_stack_result = make_userspace_context_for_main_thread(new_main_thread->regs(), *load_result.stack_region.unsafe_ptr(), m_arguments, m_environment, move(auxv));
if (make_stack_result.is_error())
return make_stack_result.error();
FlatPtr new_userspace_sp = make_stack_result.value();
auto new_userspace_sp = TRY(make_userspace_context_for_main_thread(new_main_thread->regs(), *load_result.stack_region.unsafe_ptr(), m_arguments, m_environment, move(auxv)));
if (wait_for_tracer_at_next_execve()) {
// Make sure we release the ptrace lock here or the tracer will block forever.
@ -632,7 +629,7 @@ KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_descrip
[[maybe_unused]] auto rc = big_lock().force_unlock_if_locked(lock_count_to_restore);
VERIFY_INTERRUPTS_DISABLED();
VERIFY(Processor::in_critical());
return KSuccess;
return {};
}
static Vector<ELF::AuxiliaryValue> generate_auxiliary_vector(FlatPtr load_base, FlatPtr entry_eip, UserID uid, UserID euid, GroupID gid, GroupID egid, StringView executable_path, Optional<Process::ScopedDescriptionAllocation> const& main_program_fd_allocation)
@ -673,7 +670,7 @@ static Vector<ELF::AuxiliaryValue> generate_auxiliary_vector(FlatPtr load_base,
return auxv;
}
static KResultOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_executable(char const first_page[], size_t nread)
static ErrorOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_executable(char const first_page[], size_t nread)
{
int word_start = 2;
size_t word_length = 0;
@ -711,9 +708,9 @@ static KResultOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_exec
return ENOEXEC;
}
KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size)
ErrorOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size)
{
// Not using KResultOr here because we'll want to do the same thing in userspace in the RTLD
// Not using ErrorOr here because we'll want to do the same thing in userspace in the RTLD
String interpreter_path;
if (!ELF::validate_program_headers(main_executable_header, file_size, (u8 const*)&main_executable_header, main_executable_header_size, &interpreter_path)) {
dbgln("exec({}): File has invalid ELF Program headers", path);
@ -745,7 +742,7 @@ KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executa
return ENOEXEC;
}
// Not using KResultOr here because we'll want to do the same thing in userspace in the RTLD
// Not using ErrorOr here because we'll want to do the same thing in userspace in the RTLD
String interpreter_interpreter_path;
if (!ELF::validate_program_headers(*elf_header, interp_metadata.size, (u8*)first_page, nread, &interpreter_interpreter_path)) {
dbgln("exec({}): Interpreter ({}) has invalid ELF Program headers", path, interpreter_path);
@ -776,7 +773,7 @@ KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executa
return nullptr;
}
KResult Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recursion_depth)
ErrorOr<void> Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recursion_depth)
{
if (recursion_depth > 2) {
dbgln("exec({}): SHENANIGANS! recursed too far trying to find #! interpreter", path);
@ -859,10 +856,10 @@ KResult Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString>
if (prev_flags & 0x200)
sti();
Processor::leave_critical();
return KSuccess;
return {};
}
KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
ErrorOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(exec);
@ -876,9 +873,9 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
auto path = TRY(get_syscall_path_argument(params.path));
auto copy_user_strings = [](const auto& list, auto& output) -> KResult {
auto copy_user_strings = [](const auto& list, auto& output) -> ErrorOr<void> {
if (!list.length)
return KSuccess;
return {};
Checked<size_t> size = sizeof(*list.strings);
size *= list.length;
if (size.has_overflow())
@ -892,7 +889,7 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
if (!output.try_append(move(string)))
return ENOMEM;
}
return KSuccess;
return {};
};
NonnullOwnPtrVector<KString> arguments;
@ -901,8 +898,9 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
NonnullOwnPtrVector<KString> environment;
TRY(copy_user_strings(params.environment, environment));
auto result = exec(move(path), move(arguments), move(environment));
VERIFY(result.is_error()); // We should never continue after a successful exec!
return result.error();
TRY(exec(move(path), move(arguments), move(environment)));
// We should never continue after a successful exec!
VERIFY_NOT_REACHED();
}
}

8
Kernel/Syscalls/fcntl.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
ErrorOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);
@ -40,9 +40,11 @@ KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
case F_ISTTY:
return description->is_tty();
case F_GETLK:
return description->get_flock(Userspace<flock*>(arg));
TRY(description->get_flock(Userspace<flock*>(arg)));
return 0;
case F_SETLK:
return description->apply_flock(Process::current(), Userspace<const flock*>(arg));
TRY(description->apply_flock(Process::current(), Userspace<const flock*>(arg)));
return 0;
default:
return EINVAL;
}

2
Kernel/Syscalls/fork.cpp
View file

@ -13,7 +13,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
ErrorOr<FlatPtr> Process::sys$fork(RegisterState& regs)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(proc);

5
Kernel/Syscalls/fsync.cpp
View file

@ -8,12 +8,13 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$fsync(int fd)
ErrorOr<FlatPtr> Process::sys$fsync(int fd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);
auto description = TRY(fds().open_file_description(fd));
return description->sync();
TRY(description->sync());
return 0;
}
}

5
Kernel/Syscalls/ftruncate.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length)
ErrorOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -20,7 +20,8 @@ KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_le
auto description = TRY(fds().open_file_description(fd));
if (!description->is_writable())
return EBADF;
return description->truncate(static_cast<u64>(length));
TRY(description->truncate(static_cast<u64>(length)));
return 0;
}
}

2
Kernel/Syscalls/futex.cpp
View file

@ -22,7 +22,7 @@ void Process::clear_futex_queues_on_exec()
m_futex_queues.clear();
}
KResultOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
ErrorOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
auto params = TRY(copy_typed_from_user(user_params));

9
Kernel/Syscalls/get_dir_entries.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
ErrorOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio);
@ -19,11 +19,8 @@ KResultOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_bu
auto buffer = UserOrKernelBuffer::for_user_buffer(user_buffer, static_cast<size_t>(user_size));
if (!buffer.has_value())
return EFAULT;
auto result = description->get_dir_entries(buffer.value(), user_size);
if (result.is_error())
return result.error();
else
return result.release_value();
auto count = TRY(description->get_dir_entries(buffer.value(), user_size));
return count;
}
}

5
Kernel/Syscalls/get_stack_bounds.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size)
ErrorOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
auto& regs = Thread::current()->get_register_dump_from_stack();
@ -22,7 +22,8 @@ KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_
FlatPtr stack_base = stack_region->range().base().get();
size_t stack_size = stack_region->size();
TRY(copy_to_user(user_stack_base, &stack_base));
return copy_to_user(user_stack_size, &stack_size);
TRY(copy_to_user(user_stack_size, &stack_size));
return 0;
}
}

2
Kernel/Syscalls/getrandom.cpp
View file

@ -13,7 +13,7 @@ namespace Kernel {
// 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
// do, we should be able of the caveats that Linux has dealt with.
KResultOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
ErrorOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
REQUIRE_PROMISE(stdio);

21
Kernel/Syscalls/getuid.cpp
View file

@ -8,55 +8,55 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$getuid()
ErrorOr<FlatPtr> Process::sys$getuid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return uid().value();
}
KResultOr<FlatPtr> Process::sys$getgid()
ErrorOr<FlatPtr> Process::sys$getgid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return gid().value();
}
KResultOr<FlatPtr> Process::sys$geteuid()
ErrorOr<FlatPtr> Process::sys$geteuid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return euid().value();
}
KResultOr<FlatPtr> Process::sys$getegid()
ErrorOr<FlatPtr> Process::sys$getegid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return egid().value();
}
KResultOr<FlatPtr> Process::sys$getresuid(Userspace<UserID*> ruid, Userspace<UserID*> euid, Userspace<UserID*> suid)
ErrorOr<FlatPtr> Process::sys$getresuid(Userspace<UserID*> ruid, Userspace<UserID*> euid, Userspace<UserID*> suid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
TRY(copy_to_user(ruid, &m_protected_values.uid));
TRY(copy_to_user(euid, &m_protected_values.euid));
TRY(copy_to_user(suid, &m_protected_values.suid));
return KSuccess;
return 0;
}
KResultOr<FlatPtr> Process::sys$getresgid(Userspace<GroupID*> rgid, Userspace<GroupID*> egid, Userspace<GroupID*> sgid)
ErrorOr<FlatPtr> Process::sys$getresgid(Userspace<GroupID*> rgid, Userspace<GroupID*> egid, Userspace<GroupID*> sgid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
TRY(copy_to_user(rgid, &m_protected_values.gid));
TRY(copy_to_user(egid, &m_protected_values.egid));
TRY(copy_to_user(sgid, &m_protected_values.sgid));
return KSuccess;
return 0;
}
KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
ErrorOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -64,7 +64,8 @@ KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_g
return extra_gids().size();
if (count != extra_gids().size())
return EINVAL;
return copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count);
TRY(copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count));
return 0;
}
}

8
Kernel/Syscalls/hostname.cpp
View file

@ -8,13 +8,13 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
ErrorOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_PROMISE(stdio);
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
return hostname().with_shared([&](const auto& name) -> KResultOr<FlatPtr> {
return hostname().with_shared([&](const auto& name) -> ErrorOr<FlatPtr> {
if (size < (name.length() + 1))
return ENAMETOOLONG;
TRY(copy_to_user(buffer, name.characters(), name.length() + 1));
@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size
});
}
KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_t length)
ErrorOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_t length)
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_NO_PROMISES;
@ -31,7 +31,7 @@ KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_
if (length > 64)
return ENAMETOOLONG;
auto new_name = TRY(try_copy_kstring_from_user(buffer, length));
return hostname().with_exclusive([&](auto& name) -> KResultOr<FlatPtr> {
return hostname().with_exclusive([&](auto& name) -> ErrorOr<FlatPtr> {
// FIXME: Use KString instead of String here.
name = new_name->view();
return 0;

9
Kernel/Syscalls/inode_watcher.cpp
View file

@ -13,7 +13,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
ErrorOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);
@ -34,7 +34,7 @@ KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
return fd_allocation.fd;
}
KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params)
ErrorOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);
@ -52,13 +52,14 @@ KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall:
return TRY(inode_watcher->register_inode(custody->inode(), params.event_mask));
}
KResultOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd)
ErrorOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = TRY(fds().open_file_description(fd));
if (!description->is_inode_watcher())
return EBADF;
return description->inode_watcher()->unregister_by_wd(wd);
TRY(description->inode_watcher()->unregister_by_wd(wd));
return 0;
}
}

7
Kernel/Syscalls/ioctl.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
ErrorOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = TRY(fds().open_file_description(fd));
@ -19,9 +19,10 @@ KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
int non_blocking;
TRY(copy_from_user(&non_blocking, Userspace<const int*>(arg)));
description->set_blocking(non_blocking == 0);
return KSuccess;
return 0;
}
return description->file().ioctl(*description, request, arg);
TRY(description->file().ioctl(*description, request, arg));
return 0;
}
}

6
Kernel/Syscalls/keymap.cpp
View file

@ -11,7 +11,7 @@ namespace Kernel {
constexpr size_t map_name_max_size = 50;
KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(setkeymap);
@ -37,7 +37,7 @@ KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_
return 0;
}
KResultOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*> user_params)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
REQUIRE_PROMISE(getkeymap);
@ -55,7 +55,7 @@ KResultOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_
if (params.map_name.size < keymap_name.length())
return ENAMETOOLONG;
TRY(copy_to_user(params.map_name.data, keymap_name.characters(), keymap_name.length()));
return KSuccess;
return 0;
}
}

56
Kernel/Syscalls/kill.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResult Process::do_kill(Process& process, int signal)
ErrorOr<void> Process::do_kill(Process& process, int signal)
{
// FIXME: Allow sending SIGCONT to everyone in the process group.
// FIXME: Should setuid processes have some special treatment here?
@ -21,10 +21,10 @@ KResult Process::do_kill(Process& process, int signal)
}
if (signal != 0)
return process.send_signal(signal, this);
return KSuccess;
return {};
}
KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
ErrorOr<void> Process::do_killpg(ProcessGroupID pgrp, int signal)
{
InterruptDisabler disabler;
@ -38,64 +38,64 @@ KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
bool group_was_empty = true;
bool any_succeeded = false;
KResult error = KSuccess;
ErrorOr<void> error;
Process::for_each_in_pgrp(pgrp, [&](auto& process) {
group_was_empty = false;
KResult res = do_kill(process, signal);
if (res.is_success())
ErrorOr<void> res = do_kill(process, signal);
if (!res.is_error())
any_succeeded = true;
else
error = res;
error = move(res);
});
if (group_was_empty)
return ESRCH;
if (any_succeeded)
return KSuccess;
return {};
return error;
}
KResult Process::do_killall(int signal)
ErrorOr<void> Process::do_killall(int signal)
{
InterruptDisabler disabler;
bool any_succeeded = false;
KResult error = KSuccess;
ErrorOr<void> error;
// Send the signal to all processes we have access to for.
processes().for_each([&](auto& process) {
KResult res = KSuccess;
ErrorOr<void> res;
if (process.pid() == pid())
res = do_killself(signal);
else
res = do_kill(process, signal);
if (res.is_success())
if (!res.is_error())
any_succeeded = true;
else
error = res;
error = move(res);
});
if (any_succeeded)
return KSuccess;
return {};
return error;
}
KResult Process::do_killself(int signal)
ErrorOr<void> Process::do_killself(int signal)
{
if (signal == 0)
return KSuccess;
return {};
auto current_thread = Thread::current();
if (!current_thread->should_ignore_signal(signal))
current_thread->send_signal(signal, this);
return KSuccess;
return {};
}
KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
ErrorOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (pid_or_pgid == pid().value())
@ -108,21 +108,26 @@ KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
if (pid_or_pgid < -1) {
if (pid_or_pgid == NumericLimits<i32>::min())
return EINVAL;
return do_killpg(-pid_or_pgid, signal);
TRY(do_killpg(-pid_or_pgid, signal));
return 0;
}
if (pid_or_pgid == -1) {
TRY(do_killall(signal));
return 0;
}
if (pid_or_pgid == -1)
return do_killall(signal);
if (pid_or_pgid == pid().value()) {
return do_killself(signal);
TRY(do_killself(signal));
return 0;
}
VERIFY(pid_or_pgid >= 0);
auto peer = Process::from_pid(pid_or_pgid);
if (!peer)
return ESRCH;
return do_kill(*peer, signal);
TRY(do_kill(*peer, signal));
return 0;
}
KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
ErrorOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -131,7 +136,8 @@ KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
if (pgrp < 0)
return EINVAL;
return do_killpg(pgrp, signum);
TRY(do_killpg(pgrp, signum));
return 0;
}
}

10
Kernel/Syscalls/link.cpp
View file

@ -10,17 +10,18 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
ErrorOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
auto params = TRY(copy_typed_from_user(user_params));
auto old_path = TRY(try_copy_kstring_from_user(params.old_path));
auto new_path = TRY(try_copy_kstring_from_user(params.new_path));
return VirtualFileSystem::the().link(old_path->view(), new_path->view(), current_directory());
TRY(VirtualFileSystem::the().link(old_path->view(), new_path->view(), current_directory()));
return 0;
}
KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
ErrorOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
@ -28,7 +29,8 @@ KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_para
auto target = TRY(get_syscall_path_argument(params.target));
auto linkpath = TRY(get_syscall_path_argument(params.linkpath));
return VirtualFileSystem::the().symlink(target->view(), linkpath->view(), current_directory());
TRY(VirtualFileSystem::the().symlink(target->view(), linkpath->view(), current_directory()));
return 0;
}
}

5
Kernel/Syscalls/lseek.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence)
ErrorOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -17,7 +17,8 @@ KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset
off_t offset;
TRY(copy_from_user(&offset, userspace_offset));
auto seek_result = TRY(description->seek(offset, whence));
return copy_to_user(userspace_offset, &seek_result);
TRY(copy_to_user(userspace_offset, &seek_result));
return 0;
}
}

5
Kernel/Syscalls/mkdir.cpp
View file

@ -10,11 +10,12 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode)
ErrorOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
auto path = TRY(get_syscall_path_argument(user_path, path_length));
return VirtualFileSystem::the().mkdir(path->view(), mode & ~umask(), current_directory());
TRY(VirtualFileSystem::the().mkdir(path->view(), mode & ~umask(), current_directory()));
return 0;
}
}

5
Kernel/Syscalls/mknod.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(dpath);
@ -19,7 +19,8 @@ KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*>
if (!is_superuser() && !is_regular_file(params.mode) && !is_fifo(params.mode) && !is_socket(params.mode))
return EPERM;
auto path = TRY(get_syscall_path_argument(params.path));
return VirtualFileSystem::the().mknod(path->view(), params.mode & ~umask(), params.dev, current_directory());
TRY(VirtualFileSystem::the().mknod(path->view(), params.mode & ~umask(), params.dev, current_directory()));
return 0;
}
}

23
Kernel/Syscalls/mmap.cpp
View file

@ -120,7 +120,7 @@ static bool validate_inode_mmap_prot(const Process& process, int prot, const Ino
return true;
}
KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -188,7 +188,7 @@ KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> u
Memory::Region* region = nullptr;
auto range = TRY([&]() -> KResultOr<Memory::VirtualRange> {
auto range = TRY([&]() -> ErrorOr<Memory::VirtualRange> {
if (map_randomized) {
return address_space().page_directory().range_allocator().try_allocate_randomized(Memory::page_round_up(size), alignment);
}
@ -250,7 +250,7 @@ KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> u
return region->vaddr().get();
}
static KResultOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr address, size_t size)
static ErrorOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr address, size_t size)
{
if (Memory::page_round_up_would_wrap(size))
return EINVAL;
@ -267,7 +267,7 @@ static KResultOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr a
return Memory::VirtualRange { base, end - base.get() };
}
KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot)
ErrorOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -406,7 +406,7 @@ KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int
return EINVAL;
}
KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice)
ErrorOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -441,7 +441,7 @@ KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, i
return EINVAL;
}
KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params)
ErrorOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -465,14 +465,15 @@ KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mm
return 0;
}
KResultOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
ErrorOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return address_space().unmap_mmap_range(VirtualAddress { addr }, size);
TRY(address_space().unmap_mmap_range(VirtualAddress { addr }, size));
return 0;
}
KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -509,7 +510,7 @@ KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params
return ENOTIMPL;
}
KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
ErrorOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -564,7 +565,7 @@ KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data
return m_master_tls_region.unsafe_ptr()->vaddr().get();
}
KResultOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address)
ErrorOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (address_space().enforces_syscall_regions())

18
Kernel/Syscalls/mount.cpp
View file

@ -18,7 +18,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser())
@ -42,19 +42,21 @@ KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*>
if (params.flags & MS_REMOUNT) {
// We're not creating a new mount, we're updating an existing one!
return VirtualFileSystem::the().remount(target_custody, params.flags & ~MS_REMOUNT);
TRY(VirtualFileSystem::the().remount(target_custody, params.flags & ~MS_REMOUNT));
return 0;
}
if (params.flags & MS_BIND) {
// We're doing a bind mount.
if (description_or_error.is_error())
return description_or_error.error();
return description_or_error.release_error();
auto description = description_or_error.release_value();
if (!description->custody()) {
// We only support bind-mounting inodes, not arbitrary files.
return ENODEV;
}
return VirtualFileSystem::the().bind_mount(*description->custody(), target_custody, params.flags);
TRY(VirtualFileSystem::the().bind_mount(*description->custody(), target_custody, params.flags));
return 0;
}
RefPtr<FileSystem> fs;
@ -108,10 +110,11 @@ KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*>
return ENOMEM;
TRY(fs->initialize());
return VirtualFileSystem::the().mount(fs.release_nonnull(), target_custody, params.flags);
TRY(VirtualFileSystem::the().mount(fs.release_nonnull(), target_custody, params.flags));
return 0;
}
KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
ErrorOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser())
@ -122,7 +125,8 @@ KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, s
auto mountpoint = TRY(get_syscall_path_argument(user_mountpoint, mountpoint_length));
auto custody = TRY(VirtualFileSystem::the().resolve_path(mountpoint->view(), current_directory()));
auto& guest_inode = custody->inode();
return VirtualFileSystem::the().unmount(guest_inode);
TRY(VirtualFileSystem::the().unmount(guest_inode));
return 0;
}
}

8
Kernel/Syscalls/open.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
ErrorOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -64,14 +64,16 @@ KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> u
return fd_allocation.fd;
}
KResultOr<FlatPtr> Process::sys$close(int fd)
ErrorOr<FlatPtr> Process::sys$close(int fd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
auto description = TRY(fds().open_file_description(fd));
auto result = description->close();
m_fds[fd] = {};
return result;
if (result.is_error())
return result.release_error();
return 0;
}
}

11
Kernel/Syscalls/perf_event.cpp
View file

@ -9,21 +9,22 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
ErrorOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto* events_buffer = current_perf_events_buffer();
if (!events_buffer)
return KSuccess;
return events_buffer->append(type, arg1, arg2, nullptr);
return 0;
TRY(events_buffer->append(type, arg1, arg2, nullptr));
return 0;
}
KResultOr<FlatPtr> Process::sys$perf_register_string(Userspace<char const*> user_string, size_t user_string_length)
ErrorOr<FlatPtr> Process::sys$perf_register_string(Userspace<char const*> user_string, size_t user_string_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto* events_buffer = current_perf_events_buffer();
if (!events_buffer)
return KSuccess;
return 0;
auto string = TRY(try_copy_kstring_from_user(user_string, user_string_length));
return events_buffer->register_string(move(string));

4
Kernel/Syscalls/pipe.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
ErrorOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -40,7 +40,7 @@ KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
TRY(copy_to_user(&pipefd[0], &reader_fd_allocation.fd));
TRY(copy_to_user(&pipefd[1], &writer_fd_allocation.fd));
return KSuccess;
return 0;
}
}

2
Kernel/Syscalls/pledge.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params)
ErrorOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));

2
Kernel/Syscalls/prctl.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2)
ErrorOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
switch (option) {

16
Kernel/Syscalls/process.cpp
View file

@ -9,31 +9,32 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$getpid()
ErrorOr<FlatPtr> Process::sys$getpid()
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_PROMISE(stdio);
return pid().value();
}
KResultOr<FlatPtr> Process::sys$getppid()
ErrorOr<FlatPtr> Process::sys$getppid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
return m_protected_values.ppid.value();
}
KResultOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size)
ErrorOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
if (m_name->length() + 1 > buffer_size)
return ENAMETOOLONG;
return copy_to_user(buffer, m_name->characters(), m_name->length() + 1);
TRY(copy_to_user(buffer, m_name->characters(), m_name->length() + 1));
return 0;
}
KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length)
ErrorOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -47,7 +48,7 @@ KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_nam
return 0;
}
KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
ErrorOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -58,7 +59,8 @@ KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::S
return EINVAL;
auto key = TRY(try_copy_kstring_from_user(params.key));
auto value = TRY(try_copy_kstring_from_user(params.value));
return set_coredump_property(move(key), move(value));
TRY(set_coredump_property(move(key), move(value)));
return 0;
}
}

6
Kernel/Syscalls/profiling.cpp
View file

@ -16,7 +16,7 @@ bool g_profiling_all_threads;
PerformanceEventBuffer* g_global_perf_events;
u64 g_profiling_event_mask;
KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
ErrorOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES;
@ -66,7 +66,7 @@ KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
return 0;
}
KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
ErrorOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES;
@ -96,7 +96,7 @@ KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
return 0;
}
KResultOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid)
ErrorOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES;

28
Kernel/Syscalls/ptrace.cpp
View file

@ -16,7 +16,7 @@
namespace Kernel {
static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& params, Process& caller)
static ErrorOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& params, Process& caller)
{
SpinlockLocker scheduler_lock(g_scheduler_lock);
if (params.request == PT_TRACE_ME) {
@ -24,7 +24,7 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
return EBUSY;
caller.set_wait_for_tracer_at_next_execve(true);
return KSuccess;
return 0;
}
// FIXME: PID/TID BUG
@ -57,7 +57,7 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
if (peer->state() != Thread::State::Stopped) {
peer->send_signal(SIGSTOP, &caller);
}
return KSuccess;
return 0;
}
auto* tracer = peer_process.tracer();
@ -126,7 +126,8 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
case PT_POKE:
if (!Memory::is_user_address(VirtualAddress { params.addr }))
return EFAULT;
return peer->process().poke_user_data(Userspace<u32*> { (FlatPtr)params.addr }, params.data);
TRY(peer->process().poke_user_data(Userspace<u32*> { (FlatPtr)params.addr }, params.data));
return 0;
case PT_PEEKDEBUG: {
Kernel::Syscall::SC_ptrace_peek_params peek_params {};
@ -136,22 +137,23 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
break;
}
case PT_POKEDEBUG:
return peer->poke_debug_register(reinterpret_cast<uintptr_t>(params.addr), params.data);
TRY(peer->poke_debug_register(reinterpret_cast<uintptr_t>(params.addr), params.data));
return 0;
default:
return EINVAL;
}
return KSuccess;
return 0;
}
KResultOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
ErrorOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(ptrace);
auto params = TRY(copy_typed_from_user(user_params));
auto result = handle_ptrace(params, *this);
return result.is_error() ? result.error().error() : result.value();
return result.is_error() ? result.error().code() : result.value();
}
/**
@ -164,7 +166,7 @@ bool Process::has_tracee_thread(ProcessID tracer_pid)
return false;
}
KResultOr<u32> Process::peek_user_data(Userspace<const u32*> address)
ErrorOr<u32> Process::peek_user_data(Userspace<const u32*> address)
{
// This function can be called from the context of another
// process that called PT_PEEK
@ -174,7 +176,7 @@ KResultOr<u32> Process::peek_user_data(Userspace<const u32*> address)
return data;
}
KResult Process::poke_user_data(Userspace<u32*> address, u32 data)
ErrorOr<void> Process::poke_user_data(Userspace<u32*> address, u32 data)
{
Memory::VirtualRange range = { VirtualAddress(address), sizeof(u32) };
auto* region = address_space().find_region_containing(range);
@ -204,7 +206,7 @@ KResult Process::poke_user_data(Userspace<u32*> address, u32 data)
return copy_to_user(address, &data);
}
KResultOr<u32> Thread::peek_debug_register(u32 register_index)
ErrorOr<u32> Thread::peek_debug_register(u32 register_index)
{
u32 data;
switch (register_index) {
@ -232,7 +234,7 @@ KResultOr<u32> Thread::peek_debug_register(u32 register_index)
return data;
}
KResult Thread::poke_debug_register(u32 register_index, u32 data)
ErrorOr<void> Thread::poke_debug_register(u32 register_index, u32 data)
{
switch (register_index) {
case 0:
@ -253,7 +255,7 @@ KResult Thread::poke_debug_register(u32 register_index, u32 data)
default:
return EINVAL;
}
return KSuccess;
return {};
}
}

10
Kernel/Syscalls/purge.cpp
View file

@ -12,7 +12,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$purge(int mode)
ErrorOr<FlatPtr> Process::sys$purge(int mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES;
@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
if (mode & PURGE_ALL_VOLATILE) {
NonnullRefPtrVector<Memory::AnonymousVMObject> vmobjects;
{
KResult result(KSuccess);
ErrorOr<void> result;
Memory::MemoryManager::for_each_vmobject([&](auto& vmobject) {
if (vmobject.is_anonymous()) {
// In the event that the append fails, only attempt to continue
@ -36,7 +36,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
});
if (result.is_error())
return result.error();
return result.release_error();
}
for (auto& vmobject : vmobjects) {
purged_page_count += vmobject.purge();
@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
if (mode & PURGE_ALL_CLEAN_INODE) {
NonnullRefPtrVector<Memory::InodeVMObject> vmobjects;
{
KResult result(KSuccess);
ErrorOr<void> result;
Memory::MemoryManager::for_each_vmobject([&](auto& vmobject) {
if (vmobject.is_inode()) {
// In the event that the append fails, only attempt to continue
@ -59,7 +59,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
});
if (result.is_error())
return result.error();
return result.release_error();
}
for (auto& vmobject : vmobjects) {
purged_page_count += vmobject.release_all_clean_pages();

12
Kernel/Syscalls/read.cpp
View file

@ -12,7 +12,7 @@ namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
static KResultOr<OpenFileDescription*> open_readable_file_description(Process::OpenFileDescriptions const& fds, int fd)
static ErrorOr<OpenFileDescription*> open_readable_file_description(Process::OpenFileDescriptions const& fds, int fd)
{
auto description = TRY(fds.open_file_description(fd));
if (!description->is_readable())
@ -22,7 +22,7 @@ static KResultOr<OpenFileDescription*> open_readable_file_description(Process::O
return description;
}
static KResult check_blocked_read(OpenFileDescription* description)
static ErrorOr<void> check_blocked_read(OpenFileDescription* description)
{
if (description->is_blocking()) {
if (!description->can_read()) {
@ -34,10 +34,10 @@ static KResult check_blocked_read(OpenFileDescription* description)
// TODO: handle exceptions in unblock_flags
}
}
return KSuccess;
return {};
}
KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
ErrorOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -74,7 +74,7 @@ KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
return nread;
}
KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
ErrorOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -91,7 +91,7 @@ KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
return TRY(description->read(user_buffer.value(), size));
}
KResultOr<FlatPtr> Process::sys$pread(int fd, Userspace<u8*> buffer, size_t size, off_t offset)
ErrorOr<FlatPtr> Process::sys$pread(int fd, Userspace<u8*> buffer, size_t size, off_t offset)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/readlink.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$readlink(Userspace<const Syscall::SC_readlink_params*> user_params)
ErrorOr<FlatPtr> Process::sys$readlink(Userspace<const Syscall::SC_readlink_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);

2
Kernel/Syscalls/realpath.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$realpath(Userspace<const Syscall::SC_realpath_params*> user_params)
ErrorOr<FlatPtr> Process::sys$realpath(Userspace<const Syscall::SC_realpath_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);

5
Kernel/Syscalls/rename.cpp
View file

@ -10,14 +10,15 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
ErrorOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
auto params = TRY(copy_typed_from_user(user_params));
auto old_path = TRY(get_syscall_path_argument(params.old_path));
auto new_path = TRY(get_syscall_path_argument(params.new_path));
return VirtualFileSystem::the().rename(old_path->view(), new_path->view(), current_directory());
TRY(VirtualFileSystem::the().rename(old_path->view(), new_path->view(), current_directory()));
return 0;
}
}

5
Kernel/Syscalls/rmdir.cpp
View file

@ -10,12 +10,13 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
auto path = TRY(get_syscall_path_argument(user_path, path_length));
return VirtualFileSystem::the().rmdir(path->view(), current_directory());
TRY(VirtualFileSystem::the().rmdir(path->view(), current_directory()));
return 0;
}
}

9
Kernel/Syscalls/sched.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$yield()
ErrorOr<FlatPtr> Process::sys$yield()
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
REQUIRE_PROMISE(stdio);
@ -16,7 +16,7 @@ KResultOr<FlatPtr> Process::sys$yield()
return 0;
}
KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param)
ErrorOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -41,7 +41,7 @@ KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct s
return 0;
}
KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param)
ErrorOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -68,7 +68,8 @@ KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched
priority
};
return copy_to_user(user_param, &param);
TRY(copy_to_user(user_param, &param));
return 0;
}
}

4
Kernel/Syscalls/select.cpp
View file

@ -14,7 +14,7 @@ namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
ErrorOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -121,7 +121,7 @@ KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params
return marked_fd_count;
}
KResultOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
ErrorOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);

7
Kernel/Syscalls/sendfd.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
ErrorOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(sendfd);
@ -25,10 +25,11 @@ KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
auto passing_description = TRY(fds().open_file_description(fd));
auto& local_socket = static_cast<LocalSocket&>(socket);
return local_socket.sendfd(*socket_description, move(passing_description));
TRY(local_socket.sendfd(*socket_description, move(passing_description)));
return 0;
}
KResultOr<FlatPtr> Process::sys$recvfd(int sockfd, int options)
ErrorOr<FlatPtr> Process::sys$recvfd(int sockfd, int options)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(recvfd);

10
Kernel/Syscalls/setpgid.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
ErrorOr<FlatPtr> Process::sys$getsid(pid_t pid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -24,7 +24,7 @@ KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
return process->sid().value();
}
KResultOr<FlatPtr> Process::sys$setsid()
ErrorOr<FlatPtr> Process::sys$setsid()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$setsid()
return sid().value();
}
KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
ErrorOr<FlatPtr> Process::sys$getpgid(pid_t pid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -57,7 +57,7 @@ KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
return process->pgid().value();
}
KResultOr<FlatPtr> Process::sys$getpgrp()
ErrorOr<FlatPtr> Process::sys$getpgrp()
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -77,7 +77,7 @@ SessionID Process::get_sid_from_pgid(ProcessGroupID pgid)
return sid;
}
KResultOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
ErrorOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);

16
Kernel/Syscalls/setuid.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
ErrorOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -25,7 +25,7 @@ KResultOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
return 0;
}
KResultOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
ErrorOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -41,7 +41,7 @@ KResultOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
return 0;
}
KResultOr<FlatPtr> Process::sys$setuid(UserID new_uid)
ErrorOr<FlatPtr> Process::sys$setuid(UserID new_uid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -59,7 +59,7 @@ KResultOr<FlatPtr> Process::sys$setuid(UserID new_uid)
return 0;
}
KResultOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
ErrorOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -77,7 +77,7 @@ KResultOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
return 0;
}
KResultOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
ErrorOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -103,7 +103,7 @@ KResultOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
return 0;
}
KResultOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, UserID new_suid)
ErrorOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, UserID new_suid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -129,7 +129,7 @@ KResultOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, User
return 0;
}
KResultOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, GroupID new_sgid)
ErrorOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, GroupID new_sgid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);
@ -155,7 +155,7 @@ KResultOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, Gr
return 0;
}
KResultOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
ErrorOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id);

23
Kernel/Syscalls/sigaction.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set)
ErrorOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(sigaction);
@ -41,15 +41,16 @@ KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*>
return 0;
}
KResultOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
ErrorOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
auto pending_signals = Thread::current()->pending_signals();
return copy_to_user(set, &pending_signals);
TRY(copy_to_user(set, &pending_signals));
return 0;
}
KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act)
ErrorOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(sigaction);
@ -73,24 +74,24 @@ KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*
return 0;
}
KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers)
ErrorOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
SmapDisabler disabler;
#if ARCH(I386)
//Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
// Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
u32* stack_ptr = (u32*)registers.userspace_esp;
u32 smuggled_eax = *stack_ptr;
//pop the stored eax, ebp, return address, handler and signal code
// pop the stored eax, ebp, return address, handler and signal code
stack_ptr += 5;
Thread::current()->m_signal_mask = *stack_ptr;
stack_ptr++;
//pop edi, esi, ebp, esp, ebx, edx, ecx and eax
// pop edi, esi, ebp, esp, ebx, edx, ecx and eax
memcpy(&registers.edi, stack_ptr, 8 * sizeof(FlatPtr));
stack_ptr += 8;
@ -103,17 +104,17 @@ KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& regist
registers.userspace_esp = registers.esp;
return smuggled_eax;
#else
//Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
// Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
FlatPtr* stack_ptr = (FlatPtr*)registers.userspace_rsp;
FlatPtr smuggled_rax = *stack_ptr;
//pop the stored rax, rbp, return address, handler and signal code
// pop the stored rax, rbp, return address, handler and signal code
stack_ptr += 5;
Thread::current()->m_signal_mask = *stack_ptr;
stack_ptr++;
//pop rdi, rsi, rbp, rsp, rbx, rdx, rcx, rax, r8, r9, r10, r11, r12, r13, r14 and r15
// pop rdi, rsi, rbp, rsp, rbx, rdx, rcx, rax, r8, r9, r10, r11, r12, r13, r14 and r15
memcpy(&registers.rdi, stack_ptr, 16 * sizeof(FlatPtr));
stack_ptr += 16;

63
Kernel/Syscalls/socket.cpp
View file

@ -31,7 +31,7 @@ void Process::setup_socket_fd(int fd, NonnullRefPtr<OpenFileDescription> descrip
m_fds[fd].set(*description, flags);
}
KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
ErrorOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(domain);
@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
return fd_allocation.fd;
}
KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
ErrorOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = TRY(fds().open_file_description(sockfd));
@ -53,10 +53,11 @@ KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> addr
return ENOTSOCK;
auto& socket = *description->socket();
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
return socket.bind(address, address_length);
TRY(socket.bind(address, address_length));
return 0;
}
KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
ErrorOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (backlog < 0)
@ -68,10 +69,11 @@ KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
if (socket.is_connected())
return EINVAL;
return socket.listen(backlog);
TRY(socket.listen(backlog));
return 0;
}
KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
ErrorOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(accept);
@ -129,7 +131,7 @@ KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_para
return fd_allocation.fd;
}
KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
ErrorOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = TRY(fds().open_file_description(sockfd));
@ -137,10 +139,11 @@ KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> u
return ENOTSOCK;
auto& socket = *description->socket();
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
return socket.connect(*description, user_address, user_address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
TRY(socket.connect(*description, user_address, user_address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No));
return 0;
}
KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
ErrorOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -151,10 +154,11 @@ KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
return ENOTSOCK;
auto& socket = *description->socket();
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
return socket.shutdown(how);
TRY(socket.shutdown(how));
return 0;
}
KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
ErrorOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -182,14 +186,11 @@ KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
auto data_buffer = UserOrKernelBuffer::for_user_buffer((u8*)iovs[0].iov_base, iovs[0].iov_len);
if (!data_buffer.has_value())
return EFAULT;
auto result = socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
if (result.is_error())
return result.error();
else
return result.release_value();
auto bytes_sent = TRY(socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length));
return bytes_sent;
}
KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
ErrorOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -228,7 +229,7 @@ KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> us
description->set_blocking(original_blocking);
if (result.is_error())
return result.error();
return result.release_error();
int msg_flags = 0;
@ -257,7 +258,7 @@ KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> us
}
template<bool sockname, typename Params>
KResult Process::get_sock_or_peer_name(const Params& params)
ErrorOr<void> Process::get_sock_or_peer_name(const Params& params)
{
socklen_t addrlen_value;
TRY(copy_from_user(&addrlen_value, params.addrlen, sizeof(socklen_t)));
@ -282,21 +283,23 @@ KResult Process::get_sock_or_peer_name(const Params& params)
return copy_to_user(params.addrlen, &addrlen_value);
}
KResultOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
return get_sock_or_peer_name<true>(params);
TRY(get_sock_or_peer_name<true>(params));
return 0;
}
KResultOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
return get_sock_or_peer_name<false>(params);
TRY(get_sock_or_peer_name<false>(params));
return 0;
}
KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -315,10 +318,11 @@ KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockop
return ENOTSOCK;
auto& socket = *description->socket();
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
return socket.getsockopt(*description, level, option, user_value, user_value_size);
TRY(socket.getsockopt(*description, level, option, user_value, user_value_size));
return 0;
}
KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
ErrorOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -329,10 +333,11 @@ KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockop
return ENOTSOCK;
auto& socket = *description->socket();
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
return socket.setsockopt(params.level, params.option, user_value, params.value_size);
TRY(socket.setsockopt(params.level, params.option, user_value, params.value_size));
return 0;
}
KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
ErrorOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -360,6 +365,6 @@ KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpai
m_fds[fds[1]] = {};
return EFAULT;
}
return KSuccess;
return 0;
}
}

10
Kernel/Syscalls/stat.cpp
View file

@ -11,17 +11,18 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
ErrorOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
auto description = TRY(fds().open_file_description(fd));
stat buffer = {};
TRY(description->stat(buffer));
return copy_to_user(user_statbuf, &buffer);
TRY(copy_to_user(user_statbuf, &buffer));
return 0;
}
KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
ErrorOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);
@ -43,7 +44,8 @@ KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> u
auto metadata = TRY(VirtualFileSystem::the().lookup_metadata(path->view(), *base, params.follow_symlinks ? 0 : O_NOFOLLOW_NOERROR));
stat statbuf = {};
TRY(metadata.stat(statbuf));
return copy_to_user(params.statbuf, &statbuf);
TRY(copy_to_user(params.statbuf, &statbuf));
return 0;
}
}

9
Kernel/Syscalls/statvfs.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
ErrorOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
{
auto custody = TRY(VirtualFileSystem::the().resolve_path(path, current_directory(), nullptr, 0));
auto& inode = custody->inode();
@ -58,10 +58,11 @@ KResultOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
}
}
return copy_to_user(buf, &kernelbuf);
TRY(copy_to_user(buf, &kernelbuf));
return 0;
}
KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
ErrorOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath);
@ -71,7 +72,7 @@ KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_para
return do_statvfs(path->view(), params.buf);
}
KResultOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf)
ErrorOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/sync.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$sync()
ErrorOr<FlatPtr> Process::sys$sync()
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/sysconf.cpp
View file

@ -9,7 +9,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$sysconf(int name)
ErrorOr<FlatPtr> Process::sys$sysconf(int name)
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
switch (name) {

25
Kernel/Syscalls/thread.cpp
View file

@ -13,7 +13,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::SC_create_thread_params*> user_params)
ErrorOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::SC_create_thread_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread);
@ -101,7 +101,7 @@ void Process::sys$exit_thread(Userspace<void*> exit_value, Userspace<void*> stac
VERIFY_NOT_REACHED();
}
KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
ErrorOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread);
@ -116,7 +116,7 @@ KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
return 0;
}
KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value)
ErrorOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread);
@ -133,11 +133,11 @@ KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_va
// NOTE: pthread_join() cannot be interrupted by signals. Only by death.
for (;;) {
KResult try_join_result(KSuccess);
ErrorOr<void> try_join_result;
auto result = current_thread->block<Thread::JoinBlocker>({}, *thread, try_join_result, joinee_exit_value);
if (result == Thread::BlockResult::NotBlocked) {
if (try_join_result.is_error())
return try_join_result.error();
return try_join_result.release_error();
break;
}
if (result == Thread::BlockResult::InterruptedByDeath)
@ -148,10 +148,10 @@ KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_va
if (exit_value)
TRY(copy_to_user(exit_value, &joinee_exit_value));
return KSuccess;
return 0;
}
KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
ErrorOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread);
@ -169,7 +169,7 @@ KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
return 0;
}
KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*> user_name, size_t user_name_length)
ErrorOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*> user_name, size_t user_name_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -188,7 +188,7 @@ KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*
return 0;
}
KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size)
ErrorOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread);
@ -205,16 +205,17 @@ KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buff
if (thread_name.is_null()) {
char null_terminator = '\0';
TRY(copy_to_user(buffer, &null_terminator, sizeof(null_terminator)));
return KSuccess;
return 0;
}
if (thread_name.length() + 1 > buffer_size)
return ENAMETOOLONG;
return copy_to_user(buffer, thread_name.characters_without_null_termination(), thread_name.length() + 1);
TRY(copy_to_user(buffer, thread_name.characters_without_null_termination(), thread_name.length() + 1));
return 0;
}
KResultOr<FlatPtr> Process::sys$gettid()
ErrorOr<FlatPtr> Process::sys$gettid()
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_PROMISE(stdio);

2
Kernel/Syscalls/times.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times)
ErrorOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);

10
Kernel/Syscalls/ttyname.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size)
ErrorOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(tty);
@ -21,10 +21,11 @@ KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t
auto& tty_name = description->tty()->tty_name();
if (size < tty_name.length() + 1)
return ERANGE;
return copy_to_user(buffer, tty_name.characters(), tty_name.length() + 1);
TRY(copy_to_user(buffer, tty_name.characters(), tty_name.length() + 1));
return 0;
}
KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size)
ErrorOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(tty);
@ -35,7 +36,8 @@ KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t
auto& pts_name = master_pty->pts_name();
if (size < pts_name.length() + 1)
return ERANGE;
return copy_to_user(buffer, pts_name.characters(), pts_name.length() + 1);
TRY(copy_to_user(buffer, pts_name.characters(), pts_name.length() + 1));
return 0;
}
}

2
Kernel/Syscalls/umask.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$umask(mode_t mask)
ErrorOr<FlatPtr> Process::sys$umask(mode_t mask)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);

5
Kernel/Syscalls/uname.cpp
View file

@ -8,7 +8,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
ErrorOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
REQUIRE_PROMISE(stdio);
@ -27,7 +27,8 @@ KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
memcpy(buf.nodename, name.characters(), name.length() + 1);
});
return copy_to_user(user_buf, &buf);
TRY(copy_to_user(user_buf, &buf));
return 0;
}
}

5
Kernel/Syscalls/unlink.cpp
View file

@ -10,12 +10,13 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath);
auto path = TRY(get_syscall_path_argument(user_path, path_length));
return VirtualFileSystem::the().unlink(path->view(), current_directory());
TRY(VirtualFileSystem::the().unlink(path->view(), current_directory()));
return 0;
}
}

6
Kernel/Syscalls/unveil.cpp
View file

@ -24,7 +24,7 @@ static void update_intermediate_node_permissions(UnveilNode& root_node, UnveilAc
}
}
KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
ErrorOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -84,12 +84,12 @@ KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params
auto custody_or_error = VirtualFileSystem::the().resolve_path_without_veil(path->view(), VirtualFileSystem::the().root_custody(), &parent_custody);
if (!custody_or_error.is_error()) {
new_unveiled_path = TRY(custody_or_error.value()->try_serialize_absolute_path());
} else if (custody_or_error.error() == ENOENT && parent_custody && (new_permissions & UnveilAccess::CreateOrRemove)) {
} else if (custody_or_error.error().code() == ENOENT && parent_custody && (new_permissions & UnveilAccess::CreateOrRemove)) {
auto parent_custody_path = TRY(parent_custody->try_serialize_absolute_path());
new_unveiled_path = TRY(KLexicalPath::try_join(parent_custody_path->view(), KLexicalPath::basename(path->view())));
} else {
// FIXME Should this be EINVAL?
return custody_or_error.error();
return custody_or_error.release_error();
}
auto path_parts = KLexicalPath::parts(new_unveiled_path->view());

5
Kernel/Syscalls/utime.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf)
ErrorOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(fattr);
@ -23,7 +23,8 @@ KResultOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t p
// Not a bug!
buf = { now, now };
}
return VirtualFileSystem::the().utime(path->view(), current_directory(), buf.actime, buf.modtime);
TRY(VirtualFileSystem::the().utime(path->view(), current_directory(), buf.actime, buf.modtime));
return 0;
}
}

11
Kernel/Syscalls/waitid.cpp
View file

@ -10,16 +10,16 @@
namespace Kernel {
KResultOr<siginfo_t> Process::do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options)
ErrorOr<siginfo_t> Process::do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options)
{
KResultOr<siginfo_t> result = KResult(KSuccess);
ErrorOr<siginfo_t> result = siginfo_t {};
if (Thread::current()->block<Thread::WaitBlocker>({}, options, move(waitee), result).was_interrupted())
return EINTR;
VERIFY(!result.is_error() || (options & WNOHANG) || result.error() != KSuccess);
VERIFY(!result.is_error() || (options & WNOHANG));
return result;
}
KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
ErrorOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc);
@ -55,7 +55,8 @@ KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params
dbgln_if(PROCESS_DEBUG, "sys$waitid({}, {}, {}, {})", params.idtype, params.id, params.infop, params.options);
auto siginfo = TRY(do_waitid(move(waitee), params.options));
return copy_to_user(params.infop, &siginfo);
TRY(copy_to_user(params.infop, &siginfo));
return 0;
}
}

12
Kernel/Syscalls/write.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
ErrorOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);
@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> io
auto result = do_write(*description, buffer.value(), vec.iov_len);
if (result.is_error()) {
if (nwritten == 0)
return result.error();
return result.release_error();
return nwritten;
}
nwritten += result.value();
@ -54,7 +54,7 @@ KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> io
return nwritten;
}
KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
ErrorOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
{
size_t total_nwritten = 0;
@ -81,9 +81,9 @@ KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const Use
if (nwritten_or_error.is_error()) {
if (total_nwritten > 0)
return total_nwritten;
if (nwritten_or_error.error() == EAGAIN)
if (nwritten_or_error.error().code() == EAGAIN)
continue;
return nwritten_or_error.error();
return nwritten_or_error.release_error();
}
VERIFY(nwritten_or_error.value() > 0);
total_nwritten += nwritten_or_error.value();
@ -91,7 +91,7 @@ KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const Use
return total_nwritten;
}
KResultOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
ErrorOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio);