mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 05:07:35 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T>
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:
parent
7ee10c6926
commit
79fa9765ca
262 changed files with 2415 additions and 2600 deletions
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
KResultOr<FlatPtr> Process::sys$emuctl()
|
||||
ErrorOr<FlatPtr> Process::sys$emuctl()
|
||||
{
|
||||
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
|
||||
return ENOSYS;
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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,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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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,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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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,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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 {};
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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,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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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, ¶m);
|
||||
TRY(copy_to_user(user_param, ¶m));
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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(®isters.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(®isters.rdi, stack_ptr, 16 * sizeof(FlatPtr));
|
||||
stack_ptr += 16;
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue