1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 02:27:35 +00:00

Kernel: Annotate all syscalls with VERIFY_PROCESS_BIG_LOCK_ACQUIRED

Before we start disabling acquisition of the big process lock for
specific syscalls, make sure to document and assert that all the
lock is held during all syscalls.
This commit is contained in:
Brian Gianforcaro 2021-07-18 11:20:12 -07:00 committed by Gunnar Beutner
parent 120b9bc05b
commit 9201a06027
72 changed files with 165 additions and 0 deletions

View file

@ -33,6 +33,15 @@ enum class NeedsBigProcessLock {
No No
}; };
// Declare all syscalls and associated metadata.
//
// NOTE: When declaring a new syscall or modifying an existing, please
// ensure that the proper assert is present at the top of the syscall
// implementation to both verify and document to any readers if the
// syscall aquires the big process lock or not. The asserts are:
// - VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
// - VERIFY_NO_PROCESS_BIG_LOCK(this)
//
#define ENUMERATE_SYSCALLS(S) \ #define ENUMERATE_SYSCALLS(S) \
S(yield, NeedsBigProcessLock::Yes) \ S(yield, NeedsBigProcessLock::Yes) \
S(open, NeedsBigProcessLock::Yes) \ S(open, NeedsBigProcessLock::Yes) \

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode) KResultOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$alarm(unsigned seconds) KResultOr<FlatPtr> Process::sys$alarm(unsigned seconds)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
unsigned previous_alarm_remaining = 0; unsigned previous_alarm_remaining = 0;
if (m_alarm_timer) { if (m_alarm_timer) {

View file

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

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$beep() KResultOr<FlatPtr> Process::sys$beep()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
PCSpeaker::tone_on(440); PCSpeaker::tone_on(440);
auto result = Thread::current()->sleep(Time::from_nanoseconds(200'000'000)); auto result = Thread::current()->sleep(Time::from_nanoseconds(200'000'000));
PCSpeaker::tone_off(); PCSpeaker::tone_off();

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length) KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())
@ -26,6 +27,7 @@ KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t p
KResultOr<FlatPtr> Process::sys$fchdir(int fd) KResultOr<FlatPtr> Process::sys$fchdir(int fd)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
@ -43,6 +45,7 @@ KResultOr<FlatPtr> Process::sys$fchdir(int fd)
KResultOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size) KResultOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
if (size > NumericLimits<ssize_t>::max()) if (size > NumericLimits<ssize_t>::max())

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t path_length, mode_t mode) KResultOr<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); REQUIRE_PROMISE(fattr);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())
@ -22,6 +23,7 @@ KResultOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t p
KResultOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode) KResultOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(fattr); REQUIRE_PROMISE(fattr);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$fchown(int fd, uid_t uid, gid_t gid) KResultOr<FlatPtr> Process::sys$fchown(int fd, uid_t uid, gid_t gid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(chown); REQUIRE_PROMISE(chown);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
@ -20,6 +21,7 @@ KResultOr<FlatPtr> Process::sys$fchown(int fd, uid_t uid, gid_t gid)
KResultOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params) KResultOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(chown); REQUIRE_PROMISE(chown);
Syscall::SC_chown_params params; Syscall::SC_chown_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$chroot(Userspace<const char*> user_path, size_t path_length, int mount_flags) KResultOr<FlatPtr> Process::sys$chroot(Userspace<const char*> user_path, size_t path_length, int mount_flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;
REQUIRE_PROMISE(chroot); REQUIRE_PROMISE(chroot);

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts) KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (!TimeManagement::is_valid_clock_id(clock_id)) if (!TimeManagement::is_valid_clock_id(clock_id))
@ -26,6 +27,7 @@ KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<time
KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts) KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(settime); REQUIRE_PROMISE(settime);
if (!is_superuser()) if (!is_superuser())
@ -47,6 +49,7 @@ KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<cons
KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params) KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Syscall::SC_clock_nanosleep_params params; Syscall::SC_clock_nanosleep_params params;
@ -89,6 +92,7 @@ KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_cloc
KResultOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta) KResultOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
if (user_old_delta) { if (user_old_delta) {
timespec old_delta_ts = TimeManagement::the().remaining_epoch_time_adjustment(); timespec old_delta_ts = TimeManagement::the().remaining_epoch_time_adjustment();
timeval old_delta; timeval old_delta;
@ -114,6 +118,7 @@ KResultOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Us
KResultOr<FlatPtr> Process::sys$gettimeofday(Userspace<timeval*> user_tv) KResultOr<FlatPtr> Process::sys$gettimeofday(Userspace<timeval*> user_tv)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto tv = kgettimeofday().to_timeval(); auto tv = kgettimeofday().to_timeval();
if (!copy_to_user(user_tv, &tv)) if (!copy_to_user(user_tv, &tv))

View file

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

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$disown(ProcessID pid) KResultOr<FlatPtr> Process::sys$disown(ProcessID pid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
auto process = Process::from_pid(pid); auto process = Process::from_pid(pid);
if (!process) if (!process)

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd) KResultOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(old_fd); auto description = fds().file_description(old_fd);
if (!description) if (!description)

View file

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

View file

@ -931,6 +931,7 @@ KResult Process::exec(String path, Vector<String> arguments, Vector<String> envi
KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params) KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(exec); REQUIRE_PROMISE(exec);
// NOTE: Be extremely careful with allocating any kernel memory in exec(). // NOTE: Be extremely careful with allocating any kernel memory in exec().

View file

@ -7,11 +7,17 @@
#include <Kernel/KSyms.h> #include <Kernel/KSyms.h>
#include <Kernel/PerformanceManager.h> #include <Kernel/PerformanceManager.h>
#include <Kernel/Process.h> #include <Kernel/Process.h>
#include <Kernel/Thread.h>
namespace Kernel { namespace Kernel {
void Process::sys$exit(int status) void Process::sys$exit(int status)
{ {
// FIXME: We have callers from kernel which don't aquire the big process lock.
if (Thread::current()->previous_mode() == Thread::PreviousMode::UserMode) {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
}
{ {
ProtectedDataMutationScope scope { *this }; ProtectedDataMutationScope scope { *this };
m_termination_status = status; m_termination_status = status;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg) KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
dbgln_if(IO_DEBUG, "sys$fcntl: fd={}, cmd={}, arg={}", fd, cmd, arg); dbgln_if(IO_DEBUG, "sys$fcntl: fd={}, cmd={}, arg={}", fd, cmd, arg);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);

View file

@ -16,6 +16,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs) KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
RefPtr<Thread> child_first_thread; RefPtr<Thread> child_first_thread;
auto child = Process::create(child_first_thread, m_name, uid(), gid(), pid(), m_is_kernel_process, m_cwd, m_executable, m_tty, this); auto child = Process::create(child_first_thread, m_name, uid(), gid(), pid(), m_is_kernel_process, m_cwd, m_executable, m_tty, this);

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length) KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
off_t length; off_t length;
if (!copy_from_user(&length, userspace_length)) if (!copy_from_user(&length, userspace_length))

View file

@ -84,6 +84,7 @@ void Process::clear_futex_queues_on_exec()
KResultOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params) KResultOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
Syscall::SC_futex_params params; Syscall::SC_futex_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size) KResultOr<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); REQUIRE_PROMISE(stdio);
if (user_size > NumericLimits<ssize_t>::max()) if (user_size > NumericLimits<ssize_t>::max())
return EINVAL; return EINVAL;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size) KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
auto& regs = Thread::current()->get_register_dump_from_stack(); auto& regs = Thread::current()->get_register_dump_from_stack();
FlatPtr stack_pointer = regs.userspace_sp(); FlatPtr stack_pointer = regs.userspace_sp();
auto* stack_region = space().find_region_containing(Range { VirtualAddress(stack_pointer), 1 }); auto* stack_region = space().find_region_containing(Range { VirtualAddress(stack_pointer), 1 });

View file

@ -15,6 +15,7 @@ namespace Kernel {
// do, we should be able of the caveats that Linux has dealt with. // do, we should be able of the caveats that Linux has dealt with.
KResultOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags) KResultOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (buffer_size > NumericLimits<ssize_t>::max()) if (buffer_size > NumericLimits<ssize_t>::max())
return EINVAL; return EINVAL;

View file

@ -10,30 +10,35 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$getuid() KResultOr<FlatPtr> Process::sys$getuid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return uid(); return uid();
} }
KResultOr<FlatPtr> Process::sys$getgid() KResultOr<FlatPtr> Process::sys$getgid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return gid(); return gid();
} }
KResultOr<FlatPtr> Process::sys$geteuid() KResultOr<FlatPtr> Process::sys$geteuid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return euid(); return euid();
} }
KResultOr<FlatPtr> Process::sys$getegid() KResultOr<FlatPtr> Process::sys$getegid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return egid(); return egid();
} }
KResultOr<FlatPtr> Process::sys$getresuid(Userspace<uid_t*> ruid, Userspace<uid_t*> euid, Userspace<uid_t*> suid) KResultOr<FlatPtr> Process::sys$getresuid(Userspace<uid_t*> ruid, Userspace<uid_t*> euid, Userspace<uid_t*> suid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (!copy_to_user(ruid, &m_uid) || !copy_to_user(euid, &m_euid) || !copy_to_user(suid, &m_suid)) if (!copy_to_user(ruid, &m_uid) || !copy_to_user(euid, &m_euid) || !copy_to_user(suid, &m_suid))
return EFAULT; return EFAULT;
@ -42,6 +47,7 @@ KResultOr<FlatPtr> Process::sys$getresuid(Userspace<uid_t*> ruid, Userspace<uid_
KResultOr<FlatPtr> Process::sys$getresgid(Userspace<gid_t*> rgid, Userspace<gid_t*> egid, Userspace<gid_t*> sgid) KResultOr<FlatPtr> Process::sys$getresgid(Userspace<gid_t*> rgid, Userspace<gid_t*> egid, Userspace<gid_t*> sgid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (!copy_to_user(rgid, &m_gid) || !copy_to_user(egid, &m_egid) || !copy_to_user(sgid, &m_sgid)) if (!copy_to_user(rgid, &m_gid) || !copy_to_user(egid, &m_egid) || !copy_to_user(sgid, &m_sgid))
return EFAULT; return EFAULT;
@ -50,6 +56,7 @@ KResultOr<FlatPtr> Process::sys$getresgid(Userspace<gid_t*> rgid, Userspace<gid_
KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids) KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (!count) if (!count)
return extra_gids().size(); return extra_gids().size();

View file

@ -13,6 +13,7 @@ extern Mutex* g_hostname_lock;
KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size) KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (size > NumericLimits<ssize_t>::max()) if (size > NumericLimits<ssize_t>::max())
return EINVAL; return EINVAL;
@ -26,6 +27,7 @@ KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size
KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> hostname, size_t length) KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> hostname, size_t length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES; REQUIRE_NO_PROMISES;
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -15,6 +15,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags) KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
int fd = m_fds.allocate(); int fd = m_fds.allocate();
@ -42,6 +43,7 @@ KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params) KResultOr<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); REQUIRE_PROMISE(rpath);
Syscall::SC_inode_watcher_add_watch_params params; Syscall::SC_inode_watcher_add_watch_params params;
@ -75,6 +77,7 @@ KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall:
KResultOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd) KResultOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
return EBADF; return EBADF;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg) KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
return EBADF; return EBADF;

View file

@ -13,6 +13,7 @@ constexpr size_t map_name_max_size = 50;
KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params) KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
REQUIRE_PROMISE(setkeymap); REQUIRE_PROMISE(setkeymap);
if (!is_superuser()) if (!is_superuser())

View file

@ -98,6 +98,7 @@ KResult Process::do_killself(int signal)
KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal) KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (pid_or_pgid == pid().value()) if (pid_or_pgid == pid().value())
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
else else
@ -125,6 +126,7 @@ KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum) KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
if (signum < 1 || signum >= 32) if (signum < 1 || signum >= 32)
return EINVAL; return EINVAL;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params) KResultOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath); REQUIRE_PROMISE(cpath);
Syscall::SC_link_params params; Syscall::SC_link_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
@ -27,6 +28,7 @@ KResultOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> u
KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params) KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath); REQUIRE_PROMISE(cpath);
Syscall::SC_symlink_params params; Syscall::SC_symlink_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence) KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode) KResultOr<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); REQUIRE_PROMISE(cpath);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params) KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(dpath); REQUIRE_PROMISE(dpath);
Syscall::SC_mknod_params params; Syscall::SC_mknod_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -127,6 +127,7 @@ static bool validate_inode_mmap_prot(const Process& process, int prot, const Ino
KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params) KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Syscall::SC_mmap_params params; Syscall::SC_mmap_params params;
@ -282,6 +283,7 @@ static KResultOr<Range> expand_range_to_page_boundaries(FlatPtr address, size_t
KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot) KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (prot & PROT_EXEC) { if (prot & PROT_EXEC) {
@ -436,6 +438,7 @@ KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int
KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice) KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto range_or_error = expand_range_to_page_boundaries(address, size); auto range_or_error = expand_range_to_page_boundaries(address, size);
@ -485,6 +488,7 @@ KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, i
KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params) KResultOr<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); REQUIRE_PROMISE(stdio);
Syscall::SC_set_mmap_name_params params; Syscall::SC_set_mmap_name_params params;
@ -519,6 +523,7 @@ KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mm
KResultOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size) KResultOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto result = space().unmap_mmap_range(VirtualAddress { addr }, size); auto result = space().unmap_mmap_range(VirtualAddress { addr }, size);
@ -529,6 +534,7 @@ KResultOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params) KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Syscall::SC_mremap_params params {}; Syscall::SC_mremap_params params {};
@ -578,6 +584,7 @@ KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params
KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size) KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (!size || size % PAGE_SIZE != 0) if (!size || size % PAGE_SIZE != 0)
@ -639,6 +646,7 @@ KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data
KResultOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address) KResultOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (space().enforces_syscall_regions()) if (space().enforces_syscall_regions())
return EPERM; return EPERM;

View file

@ -17,6 +17,7 @@ extern HashMap<String, OwnPtr<Module>>* g_modules;
KResultOr<FlatPtr> Process::sys$module_load(Userspace<const char*> user_path, size_t path_length) KResultOr<FlatPtr> Process::sys$module_load(Userspace<const char*> user_path, size_t path_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;
@ -146,6 +147,7 @@ KResultOr<FlatPtr> Process::sys$module_load(Userspace<const char*> user_path, si
KResultOr<FlatPtr> Process::sys$module_unload(Userspace<const char*> user_name, size_t name_length) KResultOr<FlatPtr> Process::sys$module_unload(Userspace<const char*> user_name, size_t name_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -19,6 +19,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params) KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;
@ -116,6 +117,7 @@ KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*>
KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length) KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -14,6 +14,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params) KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_open_params params; Syscall::SC_open_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;
@ -77,6 +78,7 @@ KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> u
KResultOr<FlatPtr> Process::sys$close(int fd) KResultOr<FlatPtr> Process::sys$close(int fd)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
dbgln_if(IO_DEBUG, "sys$close({}) {}", fd, description.ptr()); dbgln_if(IO_DEBUG, "sys$close({}) {}", fd, description.ptr());

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2) KResultOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto events_buffer = current_perf_events_buffer(); auto events_buffer = current_perf_events_buffer();
if (!events_buffer) { if (!events_buffer) {
if (!create_perf_events_buffer_if_needed()) if (!create_perf_events_buffer_if_needed())

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags) KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (fds().open_count() + 2 > fds().max_open()) if (fds().open_count() + 2 > fds().max_open())
return EMFILE; return EMFILE;

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params) KResultOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_pledge_params params; Syscall::SC_pledge_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2) KResultOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
switch (option) { switch (option) {
case PR_GET_DUMPABLE: case PR_GET_DUMPABLE:
return is_dumpable(); return is_dumpable();

View file

@ -11,18 +11,21 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$getpid() KResultOr<FlatPtr> Process::sys$getpid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return pid().value(); return pid().value();
} }
KResultOr<FlatPtr> Process::sys$getppid() KResultOr<FlatPtr> Process::sys$getppid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return m_ppid.value(); return m_ppid.value();
} }
KResultOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size) KResultOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (m_name.length() + 1 > buffer_size) if (m_name.length() + 1 > buffer_size)
return ENAMETOOLONG; return ENAMETOOLONG;
@ -34,6 +37,7 @@ KResultOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t
KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length) KResultOr<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); REQUIRE_PROMISE(proc);
if (user_name_length > 256) if (user_name_length > 256)
return ENAMETOOLONG; return ENAMETOOLONG;
@ -49,6 +53,7 @@ KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_nam
KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params) KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_set_coredump_metadata_params params; Syscall::SC_set_coredump_metadata_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;

View file

@ -19,6 +19,7 @@ u64 g_profiling_event_mask;
KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask) KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES; REQUIRE_NO_PROMISES;
if (pid == -1) { if (pid == -1) {
@ -68,6 +69,7 @@ KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid) KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES; REQUIRE_NO_PROMISES;
if (pid == -1) { if (pid == -1) {
@ -97,6 +99,7 @@ KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
KResultOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid) KResultOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES; REQUIRE_NO_PROMISES;
if (pid == -1) { if (pid == -1) {

View file

@ -157,6 +157,7 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
KResultOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params) KResultOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(ptrace); REQUIRE_PROMISE(ptrace);
Syscall::SC_ptrace_params params {}; Syscall::SC_ptrace_params params {};
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -15,6 +15,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$purge(int mode) KResultOr<FlatPtr> Process::sys$purge(int mode)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_NO_PROMISES; REQUIRE_NO_PROMISES;
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -14,6 +14,7 @@ using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count) KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (iov_count < 0) if (iov_count < 0)
return EINVAL; return EINVAL;
@ -70,6 +71,7 @@ KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size) KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (size == 0) if (size == 0)
return 0; return 0;

View file

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

View file

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

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params) KResultOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath); REQUIRE_PROMISE(cpath);
Syscall::SC_rename_params params; Syscall::SC_rename_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length) KResultOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath); REQUIRE_PROMISE(cpath);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$yield() KResultOr<FlatPtr> Process::sys$yield()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Thread::current()->yield_and_release_relock_big_lock(); Thread::current()->yield_and_release_relock_big_lock();
return 0; return 0;
@ -17,6 +18,7 @@ KResultOr<FlatPtr> Process::sys$yield()
KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param) KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
struct sched_param desired_param; struct sched_param desired_param;
if (!copy_from_user(&desired_param, user_param)) if (!copy_from_user(&desired_param, user_param))
@ -42,6 +44,7 @@ KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct s
KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param) KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
int priority; int priority;
{ {

View file

@ -16,6 +16,7 @@ using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params) KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Syscall::SC_select_params params {}; Syscall::SC_select_params params {};
@ -129,6 +130,7 @@ KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params
KResultOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params) KResultOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
Syscall::SC_poll_params params; Syscall::SC_poll_params params;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd) KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(sendfd); REQUIRE_PROMISE(sendfd);
auto socket_description = fds().file_description(sockfd); auto socket_description = fds().file_description(sockfd);
if (!socket_description) if (!socket_description)
@ -34,6 +35,7 @@ KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
KResultOr<FlatPtr> Process::sys$recvfd(int sockfd, int options) KResultOr<FlatPtr> Process::sys$recvfd(int sockfd, int options)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(recvfd); REQUIRE_PROMISE(recvfd);
auto socket_description = fds().file_description(sockfd); auto socket_description = fds().file_description(sockfd);
if (!socket_description) if (!socket_description)

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$getsid(pid_t pid) KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
if (pid == 0) if (pid == 0)
return sid().value(); return sid().value();
@ -26,6 +27,7 @@ KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
KResultOr<FlatPtr> Process::sys$setsid() KResultOr<FlatPtr> Process::sys$setsid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
InterruptDisabler disabler; InterruptDisabler disabler;
bool found_process_with_same_pgid_as_my_pid = false; bool found_process_with_same_pgid_as_my_pid = false;
@ -45,6 +47,7 @@ KResultOr<FlatPtr> Process::sys$setsid()
KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid) KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
if (pid == 0) if (pid == 0)
return pgid().value(); return pgid().value();
@ -57,6 +60,7 @@ KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
KResultOr<FlatPtr> Process::sys$getpgrp() KResultOr<FlatPtr> Process::sys$getpgrp()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return pgid().value(); return pgid().value();
} }
@ -77,6 +81,7 @@ SessionID Process::get_sid_from_pgid(ProcessGroupID pgid)
KResultOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid) KResultOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
ScopedSpinLock lock(g_processes_lock); // FIXME: Use a ProcessHandle ScopedSpinLock lock(g_processes_lock); // FIXME: Use a ProcessHandle
ProcessID pid = specified_pid ? ProcessID(specified_pid) : this->pid(); ProcessID pid = specified_pid ? ProcessID(specified_pid) : this->pid();

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$seteuid(uid_t new_euid) KResultOr<FlatPtr> Process::sys$seteuid(uid_t new_euid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_euid != uid() && new_euid != suid() && !is_superuser()) if (new_euid != uid() && new_euid != suid() && !is_superuser())
@ -26,6 +27,7 @@ KResultOr<FlatPtr> Process::sys$seteuid(uid_t new_euid)
KResultOr<FlatPtr> Process::sys$setegid(gid_t new_egid) KResultOr<FlatPtr> Process::sys$setegid(gid_t new_egid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_egid != gid() && new_egid != sgid() && !is_superuser()) if (new_egid != gid() && new_egid != sgid() && !is_superuser())
@ -41,6 +43,7 @@ KResultOr<FlatPtr> Process::sys$setegid(gid_t new_egid)
KResultOr<FlatPtr> Process::sys$setuid(uid_t new_uid) KResultOr<FlatPtr> Process::sys$setuid(uid_t new_uid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_uid != uid() && new_uid != euid() && !is_superuser()) if (new_uid != uid() && new_uid != euid() && !is_superuser())
@ -58,6 +61,7 @@ KResultOr<FlatPtr> Process::sys$setuid(uid_t new_uid)
KResultOr<FlatPtr> Process::sys$setgid(gid_t new_gid) KResultOr<FlatPtr> Process::sys$setgid(gid_t new_gid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_gid != gid() && new_gid != egid() && !is_superuser()) if (new_gid != gid() && new_gid != egid() && !is_superuser())
@ -75,6 +79,7 @@ KResultOr<FlatPtr> Process::sys$setgid(gid_t new_gid)
KResultOr<FlatPtr> Process::sys$setreuid(uid_t new_ruid, uid_t new_euid) KResultOr<FlatPtr> Process::sys$setreuid(uid_t new_ruid, uid_t new_euid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_ruid == (uid_t)-1) if (new_ruid == (uid_t)-1)
@ -100,6 +105,7 @@ KResultOr<FlatPtr> Process::sys$setreuid(uid_t new_ruid, uid_t new_euid)
KResultOr<FlatPtr> Process::sys$setresuid(uid_t new_ruid, uid_t new_euid, uid_t new_suid) KResultOr<FlatPtr> Process::sys$setresuid(uid_t new_ruid, uid_t new_euid, uid_t new_suid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_ruid == (uid_t)-1) if (new_ruid == (uid_t)-1)
@ -125,6 +131,7 @@ KResultOr<FlatPtr> Process::sys$setresuid(uid_t new_ruid, uid_t new_euid, uid_t
KResultOr<FlatPtr> Process::sys$setresgid(gid_t new_rgid, gid_t new_egid, gid_t new_sgid) KResultOr<FlatPtr> Process::sys$setresgid(gid_t new_rgid, gid_t new_egid, gid_t new_sgid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (new_rgid == (gid_t)-1) if (new_rgid == (gid_t)-1)
@ -150,6 +157,7 @@ KResultOr<FlatPtr> Process::sys$setresgid(gid_t new_rgid, gid_t new_egid, gid_t
KResultOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids) KResultOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(id); REQUIRE_PROMISE(id);
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -14,6 +14,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$reboot() KResultOr<FlatPtr> Process::sys$reboot()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;
@ -34,6 +35,7 @@ KResultOr<FlatPtr> Process::sys$reboot()
KResultOr<FlatPtr> Process::sys$halt() KResultOr<FlatPtr> Process::sys$halt()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser()) if (!is_superuser())
return EPERM; return EPERM;

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set) KResultOr<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); REQUIRE_PROMISE(sigaction);
auto current_thread = Thread::current(); auto current_thread = Thread::current();
u32 previous_signal_mask; u32 previous_signal_mask;
@ -43,6 +44,7 @@ KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*>
KResultOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set) KResultOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto pending_signals = Thread::current()->pending_signals(); auto pending_signals = Thread::current()->pending_signals();
if (!copy_to_user(set, &pending_signals)) if (!copy_to_user(set, &pending_signals))
@ -52,6 +54,7 @@ KResultOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act) KResultOr<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); REQUIRE_PROMISE(sigaction);
if (signum < 1 || signum >= 32 || signum == SIGKILL || signum == SIGSTOP) if (signum < 1 || signum >= 32 || signum == SIGKILL || signum == SIGSTOP)
return EINVAL; return EINVAL;
@ -77,6 +80,7 @@ KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*
KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers) KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
SmapDisabler disabler; SmapDisabler disabler;

View file

@ -34,6 +34,7 @@ void Process::setup_socket_fd(int fd, NonnullRefPtr<FileDescription> description
KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol) KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(domain); REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(domain);
if ((type & SOCK_TYPE_MASK) == SOCK_RAW && !is_superuser()) if ((type & SOCK_TYPE_MASK) == SOCK_RAW && !is_superuser())
@ -53,6 +54,7 @@ KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length) KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto description = fds().file_description(sockfd); auto description = fds().file_description(sockfd);
if (!description) if (!description)
return EBADF; return EBADF;
@ -65,6 +67,7 @@ KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> addr
KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog) KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (backlog < 0) if (backlog < 0)
return EINVAL; return EINVAL;
auto description = fds().file_description(sockfd); auto description = fds().file_description(sockfd);
@ -81,6 +84,7 @@ KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params) KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(accept); REQUIRE_PROMISE(accept);
Syscall::SC_accept4_params params; Syscall::SC_accept4_params params;
@ -148,6 +152,7 @@ KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_para
KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size) KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
int fd = m_fds.allocate(); int fd = m_fds.allocate();
if (fd < 0) if (fd < 0)
return fd; return fd;
@ -165,6 +170,7 @@ KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> u
KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how) KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (how & ~SHUT_RDWR) if (how & ~SHUT_RDWR)
return EINVAL; return EINVAL;
@ -181,6 +187,7 @@ KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags) KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
struct msghdr msg; struct msghdr msg;
if (!copy_from_user(&msg, user_msg)) if (!copy_from_user(&msg, user_msg))
@ -219,6 +226,7 @@ KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags) KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
struct msghdr msg; struct msghdr msg;
@ -326,6 +334,7 @@ int Process::get_sock_or_peer_name(const Params& params)
KResultOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params) KResultOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_getsockname_params params; Syscall::SC_getsockname_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;
@ -334,6 +343,7 @@ KResultOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockn
KResultOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params) KResultOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_getpeername_params params; Syscall::SC_getpeername_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;
@ -342,6 +352,7 @@ KResultOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeern
KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params) KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_getsockopt_params params; Syscall::SC_getsockopt_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;
@ -369,6 +380,7 @@ KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockop
KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params) KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_setsockopt_params params; Syscall::SC_setsockopt_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;
@ -385,6 +397,7 @@ KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockop
KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params) KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_socketpair_params params; Syscall::SC_socketpair_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;

View file

@ -14,6 +14,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf) KResultOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
@ -27,6 +28,7 @@ KResultOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params) KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
Syscall::SC_stat_params params; Syscall::SC_stat_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))

View file

@ -71,6 +71,7 @@ KResultOr<FlatPtr> Process::do_statvfs(String path, statvfs* buf)
KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params) KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(rpath); REQUIRE_PROMISE(rpath);
Syscall::SC_statvfs_params params; Syscall::SC_statvfs_params params;
@ -85,6 +86,7 @@ KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_para
KResultOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf) KResultOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$sync() KResultOr<FlatPtr> Process::sys$sync()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
VirtualFileSystem::sync(); VirtualFileSystem::sync();
return 0; return 0;

View file

@ -11,6 +11,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$sysconf(int name) KResultOr<FlatPtr> Process::sys$sysconf(int name)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
switch (name) { switch (name) {
case _SC_MONOTONIC_CLOCK: case _SC_MONOTONIC_CLOCK:
return 1; return 1;

View file

@ -18,6 +18,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::SC_create_thread_params*> user_params) KResultOr<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); REQUIRE_PROMISE(thread);
Syscall::SC_create_thread_params params; Syscall::SC_create_thread_params params;
@ -91,6 +92,7 @@ KResultOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<c
void Process::sys$exit_thread(Userspace<void*> exit_value, Userspace<void*> stack_location, size_t stack_size) void Process::sys$exit_thread(Userspace<void*> exit_value, Userspace<void*> stack_location, size_t stack_size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread); REQUIRE_PROMISE(thread);
if (this->thread_count() == 1) { if (this->thread_count() == 1) {
@ -114,6 +116,7 @@ void Process::sys$exit_thread(Userspace<void*> exit_value, Userspace<void*> stac
KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid) KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread); REQUIRE_PROMISE(thread);
auto thread = Thread::from_tid(tid); auto thread = Thread::from_tid(tid);
if (!thread || thread->pid() != pid()) if (!thread || thread->pid() != pid())
@ -128,6 +131,7 @@ KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value) KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread); REQUIRE_PROMISE(thread);
auto thread = Thread::from_tid(tid); auto thread = Thread::from_tid(tid);
@ -161,6 +165,7 @@ KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_va
KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal) KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(thread); REQUIRE_PROMISE(thread);
if (signal < 0 || signal >= 32) if (signal < 0 || signal >= 32)
@ -182,6 +187,7 @@ KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*> user_name, size_t user_name_length) KResultOr<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); REQUIRE_PROMISE(stdio);
auto name = copy_string_from_user(user_name, user_name_length); auto name = copy_string_from_user(user_name, user_name_length);
if (name.is_null()) if (name.is_null())
@ -201,6 +207,7 @@ KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*
KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size) KResultOr<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); REQUIRE_PROMISE(thread);
if (buffer_size == 0) if (buffer_size == 0)
return EINVAL; return EINVAL;
@ -221,6 +228,7 @@ KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buff
KResultOr<FlatPtr> Process::sys$gettid() KResultOr<FlatPtr> Process::sys$gettid()
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return Thread::current()->tid().value(); return Thread::current()->tid().value();
} }

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times) KResultOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
tms times = {}; tms times = {};
times.tms_utime = m_ticks_in_user; times.tms_utime = m_ticks_in_user;

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size) KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(tty); REQUIRE_PROMISE(tty);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)
@ -29,6 +30,7 @@ KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t
KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size) KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(tty); REQUIRE_PROMISE(tty);
auto description = fds().file_description(fd); auto description = fds().file_description(fd);
if (!description) if (!description)

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$umask(mode_t mask) KResultOr<FlatPtr> Process::sys$umask(mode_t mask)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
auto old_mask = m_umask; auto old_mask = m_umask;
ProtectedDataMutationScope scope { *this }; ProtectedDataMutationScope scope { *this };

View file

@ -10,6 +10,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf) KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
extern String* g_hostname; extern String* g_hostname;
extern Mutex* g_hostname_lock; extern Mutex* g_hostname_lock;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length) KResultOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(cpath); REQUIRE_PROMISE(cpath);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())

View file

@ -26,6 +26,7 @@ static void update_intermediate_node_permissions(UnveilNode& root_node, UnveilAc
KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params) KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
Syscall::SC_unveil_params params; Syscall::SC_unveil_params params;
if (!copy_from_user(&params, user_params)) if (!copy_from_user(&params, user_params))
return EFAULT; return EFAULT;

View file

@ -12,6 +12,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf) KResultOr<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); REQUIRE_PROMISE(fattr);
auto path = get_syscall_path_argument(user_path, path_length); auto path = get_syscall_path_argument(user_path, path_length);
if (path.is_error()) if (path.is_error())

View file

@ -20,6 +20,7 @@ KResultOr<siginfo_t> Process::do_waitid(idtype_t idtype, int id, int options)
KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params) KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
Syscall::SC_waitid_params params; Syscall::SC_waitid_params params;

View file

@ -13,6 +13,7 @@ namespace Kernel {
KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count) KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (iov_count < 0) if (iov_count < 0)
return EINVAL; return EINVAL;
@ -98,6 +99,7 @@ KResultOr<FlatPtr> Process::do_write(FileDescription& description, const UserOrK
KResultOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size) KResultOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
{ {
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
if (size == 0) if (size == 0)
return 0; return 0;