RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 19:47:46 +00:00
Code Issues Activity Actions

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Syscalls/access.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
ErrorOr<FlatPtr> Process::sys$access(Userspace<char const*> user_path, size_t path_length, int mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
TRY(require_promise(Pledge::rpath));

2
Kernel/Syscalls/chdir.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$chdir(Userspace<char const*> user_path, size_t path_length)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
TRY(require_promise(Pledge::rpath));

2
Kernel/Syscalls/chown.cpp
View file

@ -20,7 +20,7 @@ ErrorOr<FlatPtr> Process::sys$fchown(int fd, UserID uid, GroupID gid)
return 0;
}
ErrorOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
ErrorOr<FlatPtr> Process::sys$chown(Userspace<Syscall::SC_chown_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
TRY(require_promise(Pledge::chown));

6
Kernel/Syscalls/clock.cpp
View file

@ -34,7 +34,7 @@ ErrorOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timesp
return 0;
}
ErrorOr<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<timespec const*> user_ts)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
TRY(require_promise(Pledge::settime));
@ -54,7 +54,7 @@ ErrorOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const
return 0;
}
ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<Syscall::SC_clock_nanosleep_params const*> user_params)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
TRY(require_promise(Pledge::stdio));
@ -92,7 +92,7 @@ ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_
return 0;
}
ErrorOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
ErrorOr<FlatPtr> Process::sys$adjtime(Userspace<timeval const*> user_delta, Userspace<timeval*> user_old_delta)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
if (user_old_delta) {

2
Kernel/Syscalls/debug.cpp
View file

@ -18,7 +18,7 @@ ErrorOr<FlatPtr> Process::sys$dump_backtrace()
return 0;
}
ErrorOr<FlatPtr> Process::sys$dbgputstr(Userspace<const char*> characters, size_t size)
ErrorOr<FlatPtr> Process::sys$dbgputstr(Userspace<char const*> characters, size_t size)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
if (size == 0)

6
Kernel/Syscalls/execve.cpp
View file

@ -180,7 +180,7 @@ static ErrorOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& p
}
RequiredLoadRange range {};
elf_image.for_each_program_header([&range](const auto& pheader) {
elf_image.for_each_program_header([&range](auto const& pheader) {
if (pheader.type() != PT_LOAD)
return;
@ -833,7 +833,7 @@ ErrorOr<void> Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KSt
return do_exec(move(description), move(arguments), move(environment), move(interpreter_description), new_main_thread, prev_flags, *main_program_header);
}
ErrorOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
ErrorOr<FlatPtr> Process::sys$execve(Userspace<Syscall::SC_execve_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
TRY(require_promise(Pledge::exec));
@ -858,7 +858,7 @@ ErrorOr<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) -> ErrorOr<void> {
auto copy_user_strings = [](auto const& list, auto& output) -> ErrorOr<void> {
if (!list.length)
return {};
Checked<size_t> size = sizeof(*list.strings);

2
Kernel/Syscalls/fcntl.cpp
View file

@ -45,7 +45,7 @@ ErrorOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
TRY(description->get_flock(Userspace<flock*>(arg)));
return 0;
case F_SETLK:
TRY(description->apply_flock(Process::current(), Userspace<const flock*>(arg)));
TRY(description->apply_flock(Process::current(), Userspace<flock const*>(arg)));
return 0;
default:
return EINVAL;

2
Kernel/Syscalls/futex.cpp
View file

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

4
Kernel/Syscalls/hostname.cpp
View file

@ -14,7 +14,7 @@ ErrorOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
TRY(require_promise(Pledge::stdio));
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
return hostname().with_shared([&](const auto& name) -> ErrorOr<FlatPtr> {
return hostname().with_shared([&](auto const& name) -> ErrorOr<FlatPtr> {
if (size < (name->length() + 1))
return ENAMETOOLONG;
TRY(copy_to_user(buffer, name->characters(), name->length() + 1));
@ -22,7 +22,7 @@ ErrorOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
});
}
ErrorOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_t length)
ErrorOr<FlatPtr> Process::sys$sethostname(Userspace<char const*> buffer, size_t length)
{
VERIFY_NO_PROCESS_BIG_LOCK(this)
TRY(require_no_promises());

2
Kernel/Syscalls/inode_watcher.cpp
View file

@ -36,7 +36,7 @@ ErrorOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
});
}
ErrorOr<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<Syscall::SC_inode_watcher_add_watch_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::rpath));

2
Kernel/Syscalls/keymap.cpp
View file

@ -11,7 +11,7 @@ namespace Kernel {
constexpr size_t map_name_max_size = 50;
ErrorOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$setkeymap(Userspace<Syscall::SC_setkeymap_params const*> user_params)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
TRY(require_promise(Pledge::setkeymap));

4
Kernel/Syscalls/link.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
ErrorOr<FlatPtr> Process::sys$link(Userspace<Syscall::SC_link_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));
@ -21,7 +21,7 @@ ErrorOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> use
return 0;
}
ErrorOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
ErrorOr<FlatPtr> Process::sys$symlink(Userspace<Syscall::SC_symlink_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));

2
Kernel/Syscalls/mkdir.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode)
ErrorOr<FlatPtr> Process::sys$mkdir(Userspace<char const*> user_path, size_t path_length, mode_t mode)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));

2
Kernel/Syscalls/mknod.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mknod(Userspace<Syscall::SC_mknod_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::dpath));

16
Kernel/Syscalls/mmap.cpp
View file

@ -103,7 +103,7 @@ ErrorOr<void> Process::validate_mmap_prot(int prot, bool map_stack, bool map_ano
return {};
}
ErrorOr<void> Process::validate_inode_mmap_prot(int prot, const Inode& inode, bool map_shared) const
ErrorOr<void> Process::validate_inode_mmap_prot(int prot, Inode const& inode, bool map_shared) const
{
auto metadata = inode.metadata();
if ((prot & PROT_READ) && !metadata.may_read(*this))
@ -125,7 +125,7 @@ ErrorOr<void> Process::validate_inode_mmap_prot(int prot, const Inode& inode, bo
return {};
}
ErrorOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mmap(Userspace<Syscall::SC_mmap_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));
@ -322,10 +322,10 @@ ErrorOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int p
return 0;
}
if (const auto& regions = TRY(address_space().find_regions_intersecting(range_to_mprotect)); regions.size()) {
if (auto const& regions = TRY(address_space().find_regions_intersecting(range_to_mprotect)); regions.size()) {
size_t full_size_found = 0;
// Check that all intersecting regions are compatible.
for (const auto* region : regions) {
for (auto const* region : regions) {
if (!region->is_mmap())
return EPERM;
TRY(validate_mmap_prot(prot, region->is_stack(), region->vmobject().is_anonymous(), region));
@ -343,7 +343,7 @@ ErrorOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int p
if (old_region->access() == Memory::prot_to_region_access_flags(prot))
continue;
const auto intersection_to_mprotect = range_to_mprotect.intersect(old_region->range());
auto const intersection_to_mprotect = range_to_mprotect.intersect(old_region->range());
// If the region is completely covered by range, simply update the access flags
if (intersection_to_mprotect == old_region->range()) {
old_region->set_readable(prot & PROT_READ);
@ -419,7 +419,7 @@ ErrorOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int
return EINVAL;
}
ErrorOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params)
ErrorOr<FlatPtr> Process::sys$set_mmap_name(Userspace<Syscall::SC_set_mmap_name_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));
@ -451,7 +451,7 @@ ErrorOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
return 0;
}
ErrorOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mremap(Userspace<Syscall::SC_mremap_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));
@ -488,7 +488,7 @@ ErrorOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*>
return ENOTIMPL;
}
ErrorOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
ErrorOr<FlatPtr> Process::sys$allocate_tls(Userspace<char const*> initial_data, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));

4
Kernel/Syscalls/mount.cpp
View file

@ -18,7 +18,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
ErrorOr<FlatPtr> Process::sys$mount(Userspace<Syscall::SC_mount_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_no_promises());
@ -114,7 +114,7 @@ ErrorOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> u
return 0;
}
ErrorOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
ErrorOr<FlatPtr> Process::sys$umount(Userspace<char const*> user_mountpoint, size_t mountpoint_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
if (!is_superuser())

2
Kernel/Syscalls/open.cpp
View file

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

2
Kernel/Syscalls/pledge.cpp
View file

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

2
Kernel/Syscalls/poll.cpp
View file

@ -14,7 +14,7 @@ namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
ErrorOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
ErrorOr<FlatPtr> Process::sys$poll(Userspace<Syscall::SC_poll_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));

4
Kernel/Syscalls/process.cpp
View file

@ -34,7 +34,7 @@ ErrorOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t b
return 0;
}
ErrorOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length)
ErrorOr<FlatPtr> Process::sys$set_process_name(Userspace<char const*> user_name, size_t user_name_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::proc));
@ -48,7 +48,7 @@ ErrorOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name,
return 0;
}
ErrorOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
ErrorOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<Syscall::SC_set_coredump_metadata_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));

2
Kernel/Syscalls/profiling.cpp
View file

@ -23,7 +23,7 @@ ErrorOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, Userspace<u64 const*>
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_no_promises());
const auto event_mask = TRY(copy_typed_from_user(userspace_event_mask));
auto const event_mask = TRY(copy_typed_from_user(userspace_event_mask));
if (pid == -1) {
if (!is_superuser())

16
Kernel/Syscalls/ptrace.cpp
View file

@ -16,7 +16,7 @@
namespace Kernel {
static ErrorOr<FlatPtr> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& params, Process& caller)
static ErrorOr<FlatPtr> handle_ptrace(Kernel::Syscall::SC_ptrace_params const& params, Process& caller)
{
SpinlockLocker scheduler_lock(g_scheduler_lock);
if (params.request == PT_TRACE_ME) {
@ -101,7 +101,7 @@ static ErrorOr<FlatPtr> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& p
return EINVAL;
PtraceRegisters regs {};
TRY(copy_from_user(&regs, (const PtraceRegisters*)params.addr));
TRY(copy_from_user(&regs, (PtraceRegisters const*)params.addr));
auto& peer_saved_registers = peer->get_register_dump_from_stack();
// Verify that the saved registers are in usermode context
@ -114,7 +114,7 @@ static ErrorOr<FlatPtr> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& p
}
case PT_PEEK: {
auto data = TRY(peer->process().peek_user_data(Userspace<const FlatPtr*> { (FlatPtr)params.addr }));
auto data = TRY(peer->process().peek_user_data(Userspace<FlatPtr const*> { (FlatPtr)params.addr }));
TRY(copy_to_user((FlatPtr*)params.data, &data));
break;
}
@ -132,7 +132,7 @@ static ErrorOr<FlatPtr> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& p
FlatPtr tracee_ptr = (FlatPtr)params.addr;
while (buf_params.buf.size > 0) {
size_t copy_this_iteration = min(buf.size(), buf_params.buf.size);
TRY(peer->process().peek_user_data(buf.span().slice(0, copy_this_iteration), Userspace<const u8*> { tracee_ptr }));
TRY(peer->process().peek_user_data(buf.span().slice(0, copy_this_iteration), Userspace<u8 const*> { tracee_ptr }));
TRY(copy_to_user((void*)buf_params.buf.data, buf.data(), copy_this_iteration));
tracee_ptr += copy_this_iteration;
buf_params.buf.data += copy_this_iteration;
@ -156,7 +156,7 @@ static ErrorOr<FlatPtr> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& p
return 0;
}
ErrorOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
ErrorOr<FlatPtr> Process::sys$ptrace(Userspace<Syscall::SC_ptrace_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::ptrace));
@ -175,7 +175,7 @@ bool Process::has_tracee_thread(ProcessID tracer_pid)
return false;
}
ErrorOr<FlatPtr> Process::peek_user_data(Userspace<const FlatPtr*> address)
ErrorOr<FlatPtr> Process::peek_user_data(Userspace<FlatPtr const*> address)
{
// This function can be called from the context of another
// process that called PT_PEEK
@ -183,7 +183,7 @@ ErrorOr<FlatPtr> Process::peek_user_data(Userspace<const FlatPtr*> address)
return TRY(copy_typed_from_user(address));
}
ErrorOr<void> Process::peek_user_data(Span<u8> destination, Userspace<const u8*> address)
ErrorOr<void> Process::peek_user_data(Span<u8> destination, Userspace<u8 const*> address)
{
// This function can be called from the context of another
// process that called PT_PEEKBUF
@ -207,7 +207,7 @@ ErrorOr<void> Process::poke_user_data(Userspace<FlatPtr*> address, FlatPtr data)
region->set_vmobject(move(vmobject));
region->set_shared(false);
}
const bool was_writable = region->is_writable();
bool const was_writable = region->is_writable();
if (!was_writable) {
region->set_writable(true);
region->remap();

4
Kernel/Syscalls/read.cpp
View file

@ -74,8 +74,8 @@ ErrorOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov,
ErrorOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
{
const auto start_timestamp = TimeManagement::the().uptime_ms();
const auto result = read_impl(fd, buffer, size);
auto const start_timestamp = TimeManagement::the().uptime_ms();
auto const result = read_impl(fd, buffer, size);
if (Thread::current()->is_profiling_suppressed())
return result;

2
Kernel/Syscalls/readlink.cpp
View file

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

2
Kernel/Syscalls/realpath.cpp
View file

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

2
Kernel/Syscalls/rename.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
ErrorOr<FlatPtr> Process::sys$rename(Userspace<Syscall::SC_rename_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));

2
Kernel/Syscalls/rmdir.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$rmdir(Userspace<char const*> user_path, size_t path_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));

2
Kernel/Syscalls/setuid.cpp
View file

@ -167,7 +167,7 @@ ErrorOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, Grou
return 0;
}
ErrorOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
ErrorOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<gid_t const*> user_gids)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::id));

14
Kernel/Syscalls/sigaction.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set)
ErrorOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<sigset_t const*> set, Userspace<sigset_t*> old_set)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::sigaction));
@ -50,7 +50,7 @@ ErrorOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
return 0;
}
ErrorOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act)
ErrorOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<sigaction const*> user_act, Userspace<sigaction*> user_old_act)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::sigaction));
@ -184,10 +184,10 @@ ErrorOr<void> Process::remap_range_as_stack(FlatPtr address, size_t size)
return {};
}
if (const auto& regions = TRY(address_space().find_regions_intersecting(range_to_remap)); regions.size()) {
if (auto const& regions = TRY(address_space().find_regions_intersecting(range_to_remap)); regions.size()) {
size_t full_size_found = 0;
// Check that all intersecting regions are compatible.
for (const auto* region : regions) {
for (auto const* region : regions) {
if (!region->is_mmap())
return EPERM;
if (!region->vmobject().is_anonymous() || region->is_shared())
@ -201,7 +201,7 @@ ErrorOr<void> Process::remap_range_as_stack(FlatPtr address, size_t size)
// Finally, iterate over each region, either updating its access flags if the range covers it wholly,
// or carving out a new subregion with the appropriate access flags set.
for (auto* old_region : regions) {
const auto intersection_to_remap = range_to_remap.intersect(old_region->range());
auto const intersection_to_remap = range_to_remap.intersect(old_region->range());
// If the region is completely covered by range, simply update the access flags
if (intersection_to_remap == old_region->range()) {
old_region->unsafe_clear_access();
@ -250,7 +250,7 @@ ErrorOr<void> Process::remap_range_as_stack(FlatPtr address, size_t size)
return EINVAL;
}
ErrorOr<FlatPtr> Process::sys$sigaltstack(Userspace<const stack_t*> user_ss, Userspace<stack_t*> user_old_ss)
ErrorOr<FlatPtr> Process::sys$sigaltstack(Userspace<stack_t const*> user_ss, Userspace<stack_t*> user_old_ss)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::sigaction));
@ -299,7 +299,7 @@ ErrorOr<FlatPtr> Process::sys$sigaltstack(Userspace<const stack_t*> user_ss, Use
}
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigtimedwait.html
ErrorOr<FlatPtr> Process::sys$sigtimedwait(Userspace<const sigset_t*> set, Userspace<siginfo_t*> info, Userspace<const timespec*> timeout)
ErrorOr<FlatPtr> Process::sys$sigtimedwait(Userspace<sigset_t const*> set, Userspace<siginfo_t*> info, Userspace<timespec const*> timeout)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::sigaction));

24
Kernel/Syscalls/socket.cpp
View file

@ -48,7 +48,7 @@ ErrorOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
});
}
ErrorOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
ErrorOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<sockaddr const*> address, socklen_t address_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
return m_fds.with_exclusive([&](auto& fds) -> ErrorOr<FlatPtr> {
@ -80,7 +80,7 @@ ErrorOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
});
}
ErrorOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
ErrorOr<FlatPtr> Process::sys$accept4(Userspace<Syscall::SC_accept4_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::accept));
@ -93,7 +93,7 @@ ErrorOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params
socklen_t address_size = 0;
if (user_address) {
TRY(copy_from_user(&address_size, static_ptr_cast<const socklen_t*>(user_address_size)));
TRY(copy_from_user(&address_size, static_ptr_cast<socklen_t const*>(user_address_size)));
}
ScopedDescriptionAllocation fd_allocation;
@ -148,7 +148,7 @@ ErrorOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params
return fd_allocation.fd;
}
ErrorOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
ErrorOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<sockaddr const*> user_address, socklen_t user_address_size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
@ -190,7 +190,7 @@ ErrorOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*
if (iovs[0].iov_len > NumericLimits<ssize_t>::max())
return EINVAL;
Userspace<const sockaddr*> user_addr((FlatPtr)msg.msg_name);
Userspace<sockaddr const*> user_addr((FlatPtr)msg.msg_name);
socklen_t addr_length = msg.msg_namelen;
auto description = TRY(open_file_description(sockfd));
@ -286,7 +286,7 @@ ErrorOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user
}
template<bool sockname, typename Params>
ErrorOr<void> Process::get_sock_or_peer_name(const Params& params)
ErrorOr<void> Process::get_sock_or_peer_name(Params const& params)
{
socklen_t addrlen_value;
TRY(copy_from_user(&addrlen_value, params.addrlen, sizeof(socklen_t)));
@ -311,7 +311,7 @@ ErrorOr<void> Process::get_sock_or_peer_name(const Params& params)
return copy_to_user(params.addrlen, &addrlen_value);
}
ErrorOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getsockname(Userspace<Syscall::SC_getsockname_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -319,7 +319,7 @@ ErrorOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsocknam
return 0;
}
ErrorOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getpeername(Userspace<Syscall::SC_getpeername_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -327,7 +327,7 @@ ErrorOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeernam
return 0;
}
ErrorOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
ErrorOr<FlatPtr> Process::sys$getsockopt(Userspace<Syscall::SC_getsockopt_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -350,12 +350,12 @@ ErrorOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_
return 0;
}
ErrorOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
ErrorOr<FlatPtr> Process::sys$setsockopt(Userspace<Syscall::SC_setsockopt_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
Userspace<const void*> user_value((FlatPtr)params.value);
Userspace<void const*> user_value((FlatPtr)params.value);
auto description = TRY(open_file_description(params.sockfd));
if (!description->is_socket())
return ENOTSOCK;
@ -365,7 +365,7 @@ ErrorOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_
return 0;
}
ErrorOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
ErrorOr<FlatPtr> Process::sys$socketpair(Userspace<Syscall::SC_socketpair_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));

2
Kernel/Syscalls/stat.cpp
View file

@ -21,7 +21,7 @@ ErrorOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
return 0;
}
ErrorOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
ErrorOr<FlatPtr> Process::sys$stat(Userspace<Syscall::SC_stat_params const*> user_params)
{
VERIFY_NO_PROCESS_BIG_LOCK(this);
TRY(require_promise(Pledge::rpath));

2
Kernel/Syscalls/statvfs.cpp
View file

@ -37,7 +37,7 @@ ErrorOr<FlatPtr> Process::do_statvfs(FileSystem const& fs, Custody const* custod
return 0;
}
ErrorOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
ErrorOr<FlatPtr> Process::sys$statvfs(Userspace<Syscall::SC_statvfs_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::rpath));

4
Kernel/Syscalls/thread.cpp
View file

@ -12,7 +12,7 @@
namespace Kernel {
ErrorOr<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<Syscall::SC_create_thread_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::thread));
@ -169,7 +169,7 @@ ErrorOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
return 0;
}
ErrorOr<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<char const*> user_name, size_t user_name_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));

2
Kernel/Syscalls/uname.cpp
View file

@ -23,7 +23,7 @@ ErrorOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
memcpy(buf.machine, "x86_64", 7);
#endif
hostname().with_shared([&](const auto& name) {
hostname().with_shared([&](auto const& name) {
auto length = min(name->length(), UTSNAME_ENTRY_LEN - 1);
memcpy(buf.nodename, name->characters(), length);
buf.nodename[length] = '\0';

2
Kernel/Syscalls/unlink.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
ErrorOr<FlatPtr> Process::sys$unlink(Userspace<char const*> user_path, size_t path_length)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::cpath));

4
Kernel/Syscalls/unveil.cpp
View file

@ -24,7 +24,7 @@ static void update_intermediate_node_permissions(UnveilNode& root_node, UnveilAc
}
}
ErrorOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
ErrorOr<FlatPtr> Process::sys$unveil(Userspace<Syscall::SC_unveil_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
auto params = TRY(copy_typed_from_user(user_params));
@ -52,7 +52,7 @@ ErrorOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*>
// Let's work out permissions first...
unsigned new_permissions = 0;
for (const char permission : permissions->view()) {
for (char const permission : permissions->view()) {
switch (permission) {
case 'r':
new_permissions |= UnveilAccess::Read;

2
Kernel/Syscalls/utime.cpp
View file

@ -10,7 +10,7 @@
namespace Kernel {
ErrorOr<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<char const*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::fattr));

2
Kernel/Syscalls/waitid.cpp
View file

@ -19,7 +19,7 @@ ErrorOr<siginfo_t> Process::do_waitid(Variant<Empty, NonnullRefPtr<Process>, Non
return result;
}
ErrorOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
ErrorOr<FlatPtr> Process::sys$waitid(Userspace<Syscall::SC_waitid_params const*> user_params)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::proc));

4
Kernel/Syscalls/write.cpp
View file

@ -51,7 +51,7 @@ ErrorOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov,
return nwritten;
}
ErrorOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
ErrorOr<FlatPtr> Process::do_write(OpenFileDescription& description, UserOrKernelBuffer const& data, size_t data_size)
{
size_t total_nwritten = 0;
@ -87,7 +87,7 @@ ErrorOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserO
return total_nwritten;
}
ErrorOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
ErrorOr<FlatPtr> Process::sys$write(int fd, Userspace<u8 const*> data, size_t size)
{
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
TRY(require_promise(Pledge::stdio));