beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-26 01:20:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/Process.h

1066 lines
43 KiB
C
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
Kernel: Factor address space management out of the Process class This patch adds Space, a class representing a process's address space. - Each Process has a Space. - The Space owns the PageDirectory and all Regions in the Process. This allows us to reorganize sys$execve() so that it constructs and populates a new Space fully before committing to it. Previously, we would construct the new address space while still running in the old one, and encountering an error meant we had to do tedious and error-prone rollback. Those problems are now gone, replaced by what's hopefully a set of much smaller problems and missing cleanups. :^)
2021-02-08 14:45:40 +00:00
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
#pragma once
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
#include <AK/Concepts.h>
Kernel: Reduce header dependencies of Process and Thread
2020-02-16 01:01:42 +00:00
#include <AK/HashMap.h>
Kernel: Switch Process to InstrusiveList from InlineLinkedList
2021-06-06 21:40:03 +00:00
#include <AK/IntrusiveList.h>
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
#include <AK/IntrusiveListRelaxedConst.h>
Kernel: Remove ProcessInspectionHandle and make Process RefCounted By making the Process class RefCounted we don't really need ProcessInspectionHandle anymore. This also fixes some race conditions where a Process may be deleted while still being used by ProcFS. Also make sure to acquire the Process' lock when accessing regions. Last but not least, there's no reason why a thread can't be scheduled while being inspected, though in practice it won't happen anyway because the scheduler lock is held at the same time.
2020-08-02 02:04:56 +00:00
#include <AK/NonnullRefPtrVector.h>
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
#include <AK/OwnPtr.h>
Kernel: Use Userspace<T> for sys$read() and sys$stat() Add validation helper overloads as needed.
2020-07-31 14:28:37 +00:00
#include <AK/Userspace.h>
Kernel: Acquire reference to waitee before trying to block in sys$waitid Previously, we would try to acquire a reference to the all processes lock or other contended resources while holding both the scheduler lock and the thread's blocker lock. This could lead to a deadlock if we actually have to block on those other resources.
2021-08-23 04:01:04 +00:00
#include <AK/Variant.h>
Kernel: Make Region weakable and use WeakPtr<Region> instead of Region* This turns use-after-free bugs into null pointer dereferences instead.
2020-02-24 12:24:30 +00:00
#include <AK/WeakPtr.h>
Kernel: Store TTY's foreground process as a WeakPtr<Process> This ensures that we don't leave a stale PGID assigned to the TTY after the process exits, which would make PID recycling attacks possible.
2020-08-06 09:17:53 +00:00
#include <AK/Weakable.h>
Kernel: Add getrusage() syscall Only the two timeval fields are maintained, as required by the POSIX standard.
2022-01-31 21:09:30 +00:00
#include <Kernel/API/POSIX/sys/resource.h>
Kernel+LibELF: Expose ELF Auxiliary Vector to Userspace The AT_* entries are placed after the environment variables, so that they can be found by iterating until the end of the envp array, and then going even further beyond :^)
2020-07-04 23:37:36 +00:00
#include <Kernel/API/Syscall.h>
Kernel: Remove ASM_Wrapper include from platform independent processor.h
2021-11-30 22:59:05 +00:00
#include <Kernel/Assertions.h>
Kernel: Fix race causing modifying a Process to fail with a panic The ProtectedDataMutationScope cannot blindly assume that there is only exactly one thread at a time that may want to unprotect the Process. Most of the time the big lock guaranteed this, but there are some cases such as finalization (among others) where this is not necessarily guaranteed. This fixes random panics due to access violations when the ProtectedDataMutationScope protects the Process instance while another is still modifying it. Fixes #8512
2021-07-07 16:29:19 +00:00
#include <Kernel/AtomicEdgeAction.h>
Kernel: Reduce header dependencies of Process and Thread
2020-02-16 01:01:42 +00:00
#include <Kernel/FileSystem/InodeMetadata.h>
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
#include <Kernel/FileSystem/OpenFileDescription.h>
Kernel: Move UnveilNode.h into Kernel/FileSystem/
2021-08-06 12:11:45 +00:00
#include <Kernel/FileSystem/UnveilNode.h>
Kernel: Add forward declaration header
2020-02-16 00:50:16 +00:00
#include <Kernel/Forward.h>
Kernel: Some futex improvements This adds support for FUTEX_WAKE_OP, FUTEX_WAIT_BITSET, FUTEX_WAKE_BITSET, FUTEX_REQUEUE, and FUTEX_CMP_REQUEUE, as well well as global and private futex and absolute/relative timeouts against the appropriate clock. This also changes the implementation so that kernel resources are only used when a thread is blocked on a futex. Global futexes are implemented as offsets in VMObjects, so that different processes can share a futex against the same VMObject despite potentially being mapped at different virtual addresses.
2020-12-22 06:21:58 +00:00
#include <Kernel/FutexQueue.h>
Kernel: Move Mutex into Locking/
2021-07-18 07:10:27 +00:00
#include <Kernel/Locking/Mutex.h>
Kernel: Rename ProtectedValue<T> => MutexProtected<T> Let's make it obvious what we're protecting it with.
2021-08-21 21:31:15 +00:00
#include <Kernel/Locking/MutexProtected.h>
Kernel: Rename Memory::Space => Memory::AddressSpace
2021-08-06 11:57:39 +00:00
#include <Kernel/Memory/AddressSpace.h>
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
#include <Kernel/PerformanceEventBuffer.h>
Kernel: Steer away from heap allocations for ProcFS process data Instead, use more static patterns to acquire that sort of data.
2021-08-10 17:51:28 +00:00
#include <Kernel/ProcessExposed.h>
Kernel: Distinguish between new and old process groups with equal pgids This does not add any behaviour change to the processes, but it ties a TTY to an active process group via TIOCSPGRP, and returns the TTY to the kernel when all processes in the process group die. Also makes the TTY keep a link to the original controlling process' parent (for SIGCHLD) instead of the process itself.
2020-08-15 19:13:19 +00:00
#include <Kernel/ProcessGroup.h>
Kernel: Add "setkeymap" pledge promise
2020-06-18 20:18:44 +00:00
#include <Kernel/StdLib.h>
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
#include <Kernel/Thread.h>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
#include <Kernel/UnixTypes.h>
LibC+LibELF: Implement support for the dl_iterate_phdr helper This helper is used by libgcc_s to figure out where the .eh_frame sections are located for all loaded shared objects.
2021-04-16 19:53:43 +00:00
#include <LibC/elf.h>
Kernel: Send more specific signals when crashing due to CPU exceptions. - For division by zero, send SIGFPE. - For illegal instruction, send SIGILL. - For the rest, default to SIGSEGV.
2019-05-26 00:08:51 +00:00
#include <LibC/signal_numbers.h>
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Kernel: Convert hostname to KString
2022-01-12 22:27:33 +00:00
MutexProtected<OwnPtr<KString>>& hostname();
Kernel: Make kgettimeofday use AK::Time
2021-02-28 01:18:48 +00:00
Time kgettimeofday();
Add support for socket send/receive timeouts. Only the receive timeout is hooked up yet. You can change the timeout by calling setsockopt(..., SOL_SOCKET, SO_RCVTIMEO, ...). Use this mechanism to make /bin/ping report timeouts.
2019-03-13 12:13:23 +00:00
Kernel: Add "setkeymap" pledge promise
2020-06-18 20:18:44 +00:00
#define ENUMERATE_PLEDGE_PROMISES \
__ENUMERATE_PLEDGE_PROMISE(stdio) \
__ENUMERATE_PLEDGE_PROMISE(rpath) \
__ENUMERATE_PLEDGE_PROMISE(wpath) \
__ENUMERATE_PLEDGE_PROMISE(cpath) \
__ENUMERATE_PLEDGE_PROMISE(dpath) \
__ENUMERATE_PLEDGE_PROMISE(inet) \
__ENUMERATE_PLEDGE_PROMISE(id) \
__ENUMERATE_PLEDGE_PROMISE(proc) \
Kernel: Add dedicated "ptrace" pledge promise The vast majority of programs don't ever need to use sys$ptrace(), and it seems like a high-value system call to prevent a compromised process from using. This patch moves sys$ptrace() from the "proc" promise to its own, new "ptrace" promise and updates the affected apps.
2021-01-11 21:30:57 +00:00
__ENUMERATE_PLEDGE_PROMISE(ptrace) \
Kernel: Add "setkeymap" pledge promise
2020-06-18 20:18:44 +00:00
__ENUMERATE_PLEDGE_PROMISE(exec) \
__ENUMERATE_PLEDGE_PROMISE(unix) \
Kernel+LibC: Add sys$recvfd() and sys$sendfd() for fd passing These new syscalls allow you to send and receive file descriptors over a local domain socket. This will enable various privilege separation techniques and other good stuff. :^)
2020-06-24 20:57:37 +00:00
__ENUMERATE_PLEDGE_PROMISE(recvfd) \
__ENUMERATE_PLEDGE_PROMISE(sendfd) \
Kernel: Add "setkeymap" pledge promise
2020-06-18 20:18:44 +00:00
__ENUMERATE_PLEDGE_PROMISE(fattr) \
__ENUMERATE_PLEDGE_PROMISE(tty) \
__ENUMERATE_PLEDGE_PROMISE(chown) \
__ENUMERATE_PLEDGE_PROMISE(thread) \
__ENUMERATE_PLEDGE_PROMISE(video) \
__ENUMERATE_PLEDGE_PROMISE(accept) \
__ENUMERATE_PLEDGE_PROMISE(settime) \
Kernel: Introduce "sigaction" pledge You now have to pledge "sigaction" to change signal handlers/dispositions. This is to prevent malicious code from messing with assertions (and segmentation faults), which are normally expected to instantly terminate the process but can do other things if you change signal disposition for them.
2020-05-26 10:49:35 +00:00
__ENUMERATE_PLEDGE_PROMISE(sigaction) \
Kernel: Add "prot_exec" pledge promise and require it for PROT_EXEC This prevents sys$mmap() and sys$mprotect() from creating executable memory mappings in pledged programs that don't have this promise. Note that the dynamic loader runs before pledging happens, so it's unaffected by this.
2021-01-29 17:50:27 +00:00
__ENUMERATE_PLEDGE_PROMISE(setkeymap) \
Kernel+keymap+KeyboardMapper: New pledge for getkeymap
2021-01-31 21:50:17 +00:00
__ENUMERATE_PLEDGE_PROMISE(prot_exec) \
Kernel: Add "map_fixed" pledge promise This is a new promise that guards access to mmap() with MAP_FIXED. Fixed-address mappings are rarely used, but can be useful if you are trying to groom the process address space for malicious purposes. None of our programs need this at the moment, as the only user of MAP_FIXED is DynamicLoader, but the fixed mappings are constructed before the process has had a chance to pledge anything.
2021-02-21 00:08:48 +00:00
__ENUMERATE_PLEDGE_PROMISE(map_fixed) \
Kernel: Add a 'no_error' pledge promise This makes pledge() ignore promises that would otherwise cause it to fail with EPERM, which is very useful for allowing programs to run under a "jail" so to speak, without having them termiate early due to a failing pledge() call.
2022-03-24 20:47:42 +00:00
__ENUMERATE_PLEDGE_PROMISE(getkeymap) \
__ENUMERATE_PLEDGE_PROMISE(no_error)
ping: Use pledge()
2020-01-11 19:48:43 +00:00
enum class Pledge : u32 {
#define __ENUMERATE_PLEDGE_PROMISE(x) x,
ENUMERATE_PLEDGE_PROMISES
#undef __ENUMERATE_PLEDGE_PROMISE
};
Kernel: Rename UnveilState to VeilState
2020-01-21 18:28:29 +00:00
enum class VeilState {
Kernel: Add a basic implementation of unveil() This syscall is a complement to pledge() and adds the same sort of incremental relinquishing of capabilities for filesystem access. The first call to unveil() will "drop a veil" on the process, and from now on, only unveiled parts of the filesystem are visible to it. Each call to unveil() specifies a path to either a directory or a file along with permissions for that path. The permissions are a combination of the following: - r: Read access (like the "rpath" promise) - w: Write access (like the "wpath" promise) - x: Execute access - c: Create/remove access (like the "cpath" promise) Attempts to open a path that has not been unveiled with fail with ENOENT. If the unveiled path lacks sufficient permissions, it will fail with EACCES. Like pledge(), subsequent calls to unveil() with the same path can only remove permissions, not add them. Once you call unveil(nullptr, nullptr), the veil is locked, and it's no longer possible to unveil any more paths for the process, ever. This concept comes from OpenBSD, and their implementation does various things differently, I'm sure. This is just a first implementation for SerenityOS, and we'll keep improving on it as we go. :^)
2020-01-20 21:12:04 +00:00
None,
Kernel: Rename UnveilState to VeilState
2020-01-21 18:28:29 +00:00
Dropped,
Locked,
Kernel: Add a basic implementation of unveil() This syscall is a complement to pledge() and adds the same sort of incremental relinquishing of capabilities for filesystem access. The first call to unveil() will "drop a veil" on the process, and from now on, only unveiled parts of the filesystem are visible to it. Each call to unveil() specifies a path to either a directory or a file along with permissions for that path. The permissions are a combination of the following: - r: Read access (like the "rpath" promise) - w: Write access (like the "wpath" promise) - x: Execute access - c: Create/remove access (like the "cpath" promise) Attempts to open a path that has not been unveiled with fail with ENOENT. If the unveiled path lacks sufficient permissions, it will fail with EACCES. Like pledge(), subsequent calls to unveil() with the same path can only remove permissions, not add them. Once you call unveil(nullptr, nullptr), the veil is locked, and it's no longer possible to unveil any more paths for the process, ever. This concept comes from OpenBSD, and their implementation does various things differently, I'm sure. This is just a first implementation for SerenityOS, and we'll keep improving on it as we go. :^)
2020-01-20 21:12:04 +00:00
};
Kernel: Clean up sys$futex and add support for cross-process futexes
2022-07-13 22:25:35 +00:00
static constexpr FlatPtr futex_key_private_flag = 0b1;
union GlobalFutexKey {
struct {
Memory::VMObject const* vmobject;
FlatPtr offset;
} shared;
struct {
Memory::AddressSpace const* address_space;
FlatPtr user_address;
} private_;
struct {
FlatPtr parent;
FlatPtr offset;
} raw;
};
static_assert(sizeof(GlobalFutexKey) == (sizeof(FlatPtr) * 2));
Kernel: Some futex improvements This adds support for FUTEX_WAKE_OP, FUTEX_WAIT_BITSET, FUTEX_WAKE_BITSET, FUTEX_REQUEUE, and FUTEX_CMP_REQUEUE, as well well as global and private futex and absolute/relative timeouts against the appropriate clock. This also changes the implementation so that kernel resources are only used when a thread is blocked on a futex. Global futexes are implemented as offsets in VMObjects, so that different processes can share a futex against the same VMObject despite potentially being mapped at different virtual addresses.
2020-12-22 06:21:58 +00:00
Kernel: Factor address space management out of the Process class This patch adds Space, a class representing a process's address space. - Each Process has a Space. - The Space owns the PageDirectory and all Regions in the Process. This allows us to reorganize sys$execve() so that it constructs and populates a new Space fully before committing to it. Previously, we would construct the new address space while still running in the old one, and encountering an error meant we had to do tedious and error-prone rollback. Those problems are now gone, replaced by what's hopefully a set of much smaller problems and missing cleanups. :^)
2021-02-08 14:45:40 +00:00
struct LoadResult;
Kernel: Make Process final This silences a clangd diagnostic about Process holding virtual functions but having a non-virtual destructor.
2021-08-14 13:20:13 +00:00
class Process final
Kernel: Port Process to ListedRefCounted
2021-12-28 22:46:21 +00:00
: public ListedRefCounted<Process, LockType::Spinlock>
Kernel: Store TTY's foreground process as a WeakPtr<Process> This ensures that we don't leave a stale PGID assigned to the TTY after the process exits, which would make PID recycling attacks possible.
2020-08-06 09:17:53 +00:00
, public Weakable<Process> {
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
class ProtectedValues {
public:
ProcessID pid { 0 };
ProcessID ppid { 0 };
SessionID sid { 0 };
Kernel: Strongly typed user & group ID's Prior to this change, both uid_t and gid_t were typedef'ed to `u32`. This made it easy to use them interchangeably. Let's not allow that. This patch adds UserID and GroupID using the AK::DistinctNumeric mechanism we've already been employing for pid_t/ProcessID.
2021-08-28 20:11:16 +00:00
UserID euid { 0 };
GroupID egid { 0 };
UserID uid { 0 };
GroupID gid { 0 };
UserID suid { 0 };
GroupID sgid { 0 };
Vector<GroupID> extra_gids;
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
bool dumpable { false };
Atomic<bool> has_promises { false };
Atomic<u32> promises { 0 };
Atomic<bool> has_execpromises { false };
Atomic<u32> execpromises { 0 };
mode_t umask { 022 };
VirtualAddress signal_trampoline;
Atomic<u32> thread_count { 0 };
u8 termination_status { 0 };
u8 termination_signal { 0 };
};
public:
Kernel: Make Process and Thread non-copyable and non-movable
2020-04-22 09:54:58 +00:00
AK_MAKE_NONCOPYABLE(Process);
AK_MAKE_NONMOVABLE(Process);
Kernel: Don't keep protected Process data in a separate allocation The previous architecture had a huge flaw: the pointer to the protected data was itself unprotected, allowing you to overwrite it at any time. This patch reorganizes the protected data so it's part of the Process class itself. (Actually, it's a new ProcessBase helper class.) We use the first 4 KB of Process objects themselves as the new storage location for protected data. Then we make Process objects page-aligned using MAKE_ALIGNED_ALLOCATED. This allows us to easily turn on/off write-protection for everything in the ProcessBase portion of Process. :^) Thanks to @bugaevc for pointing out the flaw! This is still not perfect but it's an improvement.
2021-03-11 12:13:05 +00:00
MAKE_ALIGNED_ALLOCATED(Process, PAGE_SIZE);
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
friend class Thread;
Everywhere: Core dump => Coredump We all know what a coredump is, and it feels more natural to refer to it as a coredump (most code already does), so let's be consistent.
2021-08-22 12:51:04 +00:00
friend class Coredump;
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
// Helper class to temporarily unprotect a process's protected data so you can write to it.
Kernel: Don't keep protected Process data in a separate allocation The previous architecture had a huge flaw: the pointer to the protected data was itself unprotected, allowing you to overwrite it at any time. This patch reorganizes the protected data so it's part of the Process class itself. (Actually, it's a new ProcessBase helper class.) We use the first 4 KB of Process objects themselves as the new storage location for protected data. Then we make Process objects page-aligned using MAKE_ALIGNED_ALLOCATED. This allows us to easily turn on/off write-protection for everything in the ProcessBase portion of Process. :^) Thanks to @bugaevc for pointing out the flaw! This is still not perfect but it's an improvement.
2021-03-11 12:13:05 +00:00
class ProtectedDataMutationScope {
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
public:
Kernel: Don't keep protected Process data in a separate allocation The previous architecture had a huge flaw: the pointer to the protected data was itself unprotected, allowing you to overwrite it at any time. This patch reorganizes the protected data so it's part of the Process class itself. (Actually, it's a new ProcessBase helper class.) We use the first 4 KB of Process objects themselves as the new storage location for protected data. Then we make Process objects page-aligned using MAKE_ALIGNED_ALLOCATED. This allows us to easily turn on/off write-protection for everything in the ProcessBase portion of Process. :^) Thanks to @bugaevc for pointing out the flaw! This is still not perfect but it's an improvement.
2021-03-11 12:13:05 +00:00
explicit ProtectedDataMutationScope(Process& process)
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
: m_process(process)
{
m_process.unprotect_data();
}
Kernel: Don't keep protected Process data in a separate allocation The previous architecture had a huge flaw: the pointer to the protected data was itself unprotected, allowing you to overwrite it at any time. This patch reorganizes the protected data so it's part of the Process class itself. (Actually, it's a new ProcessBase helper class.) We use the first 4 KB of Process objects themselves as the new storage location for protected data. Then we make Process objects page-aligned using MAKE_ALIGNED_ALLOCATED. This allows us to easily turn on/off write-protection for everything in the ProcessBase portion of Process. :^) Thanks to @bugaevc for pointing out the flaw! This is still not perfect but it's an improvement.
2021-03-11 12:13:05 +00:00
~ProtectedDataMutationScope() { m_process.protect_data(); }
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
private:
Process& m_process;
};
Kernel: Ignore subsequent calls to Process::die It's possible that another thread might try to exit the process just about the same time another thread does the same, or a crash happens. Also, we may not be able to kill all other threads instantly as they may be blocked in the kernel (though in this case they would get killed before ever returning back to user mode. So keep track of whether Process::die was already called and ignore it on subsequent calls. Fixes #8485
2021-07-13 23:15:24 +00:00
enum class State : u8 {
Running = 0,
Dying,
Dead
};
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
public:
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
class ProcessProcFSTraits;
Kernel: Make Process::current() return a Process& instead of Process* This has several benefits: 1) We no longer just blindly derefence a null pointer in various places 2) We will get nicer runtime error messages if the current process does turn out to be null in the call location 3) GCC no longer complains about possible nullptr dereferences when compiling without KUBSAN
2021-08-19 19:45:07 +00:00
inline static Process& current()
Kernel: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
{
Kernel: Resolve clang-tidy readability-qualified-auto warning ... In files included by Kernel/Process.cpp or Kernel/Thread.cpp
2021-10-31 22:36:52 +00:00
auto* current_thread = Processor::current_thread();
Kernel: Make Process::current() return a Process& instead of Process* This has several benefits: 1) We no longer just blindly derefence a null pointer in various places 2) We will get nicer runtime error messages if the current process does turn out to be null in the call location 3) GCC no longer complains about possible nullptr dereferences when compiling without KUBSAN
2021-08-19 19:45:07 +00:00
VERIFY(current_thread);
return current_thread->process();
}
inline static bool has_current()
{
Kernel: Resolve clang-tidy readability-implicit-bool-conversion warnings ... In files included from Kernel/Process.cpp and Kernel/Thread.cpp
2021-11-06 21:06:08 +00:00
return Processor::current_thread() != nullptr;
Kernel: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
}
Kernel: Replace "current" with Thread::current and Process::current Suggested by Sergey. The currently running Thread and Process are now Thread::current and Process::current respectively. :^)
2020-02-17 14:04:27 +00:00
Kernel: Pass trampolines instead of lambdas to create_kernel_process With -Og, all calls to create_kernel_process were triggering -Wnonnull when creating these lambdas that get implicitly converted to function pointers. A different design of create_kernel_process to use AK::Function instead might avoid this awkward behavior.
2021-05-23 19:45:58 +00:00
template<typename EntryFunction>
static void kernel_process_trampoline(void* data)
{
EntryFunction* func = reinterpret_cast<EntryFunction*>(data);
(*func)();
delete func;
}
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
enum class RegisterProcess {
No,
Yes
};
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
template<typename EntryFunction>
Kernel: Store process names as KString
2021-09-07 10:53:28 +00:00
static RefPtr<Process> create_kernel_process(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, EntryFunction entry, u32 affinity = THREAD_AFFINITY_DEFAULT, RegisterProcess do_register = RegisterProcess::Yes)
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
{
auto* entry_func = new EntryFunction(move(entry));
Kernel: Initialize threading and process management earlier This re-arranges the order of how things are initialized so that we try to initialize process and thread management earlier. This is neccessary because a lot of the code uses the Lock class, which really needs to have a running scheduler in place so that we can properly preempt. This also enables us to potentially initialize some things in parallel.
2021-07-09 01:37:36 +00:00
return create_kernel_process(first_thread, move(name), &Process::kernel_process_trampoline<EntryFunction>, entry_func, affinity, do_register);
Kernel: Allow passing a thread argument for new kernel threads This adds the ability to pass a pointer to kernel thread/process. Also add the ability to use a closure as thread function, which allows passing information to a kernel thread more easily.
2020-11-17 03:51:34 +00:00
}
Kernel: Store process names as KString
2021-09-07 10:53:28 +00:00
static RefPtr<Process> create_kernel_process(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, void (*entry)(void*), void* entry_data = nullptr, u32 affinity = THREAD_AFFINITY_DEFAULT, RegisterProcess do_register = RegisterProcess::Yes);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
static ErrorOr<NonnullRefPtr<Process>> try_create_user_process(RefPtr<Thread>& first_thread, StringView path, UserID, GroupID, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, TTY*);
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
static void register_new(Process&);
Kernel: Handle removal of Process from list before unref This makes the following scenario impossible with an SMP setup: 1) CPU A enters unref() and decrements the link count to 0. 2) CPU B sees the process in the process list and ref()s it. 3) CPU A removes the process from the list and continues destructing. 4) CPU B is now holding a destructed Process object. By holding the process list lock before doing anything with it, we ensure that other CPUs can't find this process in the middle of it being destructed.
2021-08-14 13:11:40 +00:00
Process now maps regions immediately when they are allocated. This avoids having to do a separate MM.mapRegionsForTask() pass. Also, more Task => Process renaming that I apparently hadn't saved yet.
2018-11-01 12:15:46 +00:00
~Process();
Generate a basic /proc/summary file with some info about all tasks.
2018-10-23 10:44:46 +00:00
Kernel: Make Threads always have a name We previously allowed Thread to exist in a state where its m_name was null, and had to work around that in various places. This patch removes that possibility and forces those who would create a thread (or change the name of one) to provide a NonnullOwnPtr<KString> with the name.
2021-09-06 10:44:27 +00:00
RefPtr<Thread> create_kernel_thread(void (*entry)(void*), void* entry_data, u32 priority, NonnullOwnPtr<KString> name, u32 affinity = THREAD_AFFINITY_DEFAULT, bool joinable = true);
Kernel: Turn Thread::current and Process::current into functions This allows us to query the current thread and process on a per processor basis
2020-06-28 21:34:31 +00:00
Kernel: Implement a simple process time profiler The kernel now supports basic profiling of all the threads in a process by calling profiling_enable(pid_t). You finish the profiling by calling profiling_disable(pid_t). This all works by recording thread stacks when the timer interrupt fires and the current thread is in a process being profiled. Note that symbolication is deferred until profiling_disable() to avoid adding more noise than necessary to the profile. A simple "/bin/profile" command is included here that can be used to start/stop profiling like so: $ profile 10 on ... wait ... $ profile 10 off After a profile has been recorded, it can be fetched in /proc/profile There are various limits (or "bugs") on this mechanism at the moment: - Only one process can be profiled at a time. - We allocate 8MB for the samples, if you use more space, things will not work, and probably break a bit. - Things will probably fall apart if the profiled process dies during profiling, or while extracing /proc/profile
2019-12-11 19:36:56 +00:00
bool is_profiling() const { return m_profiling; }
void set_profiling(bool profiling) { m_profiling = profiling; }
Everywhere: Core dump => Coredump We all know what a coredump is, and it feels more natural to refer to it as a coredump (most code already does), so let's be consistent.
2021-08-22 12:51:04 +00:00
bool should_generate_coredump() const { return m_should_generate_coredump; }
void set_should_generate_coredump(bool b) { m_should_generate_coredump = b; }
Kernel: Implement a simple process time profiler The kernel now supports basic profiling of all the threads in a process by calling profiling_enable(pid_t). You finish the profiling by calling profiling_disable(pid_t). This all works by recording thread stacks when the timer interrupt fires and the current thread is in a process being profiled. Note that symbolication is deferred until profiling_disable() to avoid adding more noise than necessary to the profile. A simple "/bin/profile" command is included here that can be used to start/stop profiling like so: $ profile 10 on ... wait ... $ profile 10 off After a profile has been recorded, it can be fetched in /proc/profile There are various limits (or "bugs") on this mechanism at the moment: - Only one process can be profiled at a time. - We allocate 8MB for the samples, if you use more space, things will not work, and probably break a bit. - Things will probably fall apart if the profiled process dies during profiling, or while extracing /proc/profile
2019-12-11 19:36:56 +00:00
Kernel: Ignore subsequent calls to Process::die It's possible that another thread might try to exit the process just about the same time another thread does the same, or a crash happens. Also, we may not be able to kill all other threads instantly as they may be blocked in the kernel (though in this case they would get killed before ever returning back to user mode. So keep track of whether Process::die was already called and ignore it on subsequent calls. Fixes #8485
2021-07-13 23:15:24 +00:00
bool is_dying() const { return m_state.load(AK::MemoryOrder::memory_order_acquire) != State::Running; }
bool is_dead() const { return m_state.load(AK::MemoryOrder::memory_order_acquire) == State::Dead; }
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
Kernel: Specify default memory order for some non-synchronizing Atomics
2021-01-03 23:58:50 +00:00
bool is_stopped() const { return m_is_stopped; }
bool set_stopped(bool stopped) { return m_is_stopped.exchange(stopped); }
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
Kernel: Rename Process::is_ring0/3 to Process::is_kernel/user_process Since "rings" typically refer to code execution and user processes can also execute in ring 0, rename these functions to more accurately describe what they mean: kernel processes and user processes.
2020-09-10 15:46:24 +00:00
bool is_kernel_process() const { return m_is_kernel_process; }
bool is_user_process() const { return !m_is_kernel_process; }
Implement sending signals to blocked-in-kernel processes. This is dirty but pretty cool! If we have a pending, unmasked signal for a process that's blocked inside the kernel, we set up alternate stacks for that process and unblock it to execute the signal handler. A slightly different return trampoline is used here: since we need to get back into the kernel, a dedicated syscall is used (sys$sigreturn.) This restores the TSS contents of the process to the state it was in while we were originally blocking in the kernel. NOTE: There's currently only one "kernel resume TSS" so signal nesting definitely won't work.
2018-11-07 20:19:47 +00:00
Kernel: PID/TID typing This compiles, and contains exactly the same bugs as before. The regex 'FIXME: PID/' should reveal all markers that I left behind, including: - Incomplete conversion - Issues or things that look fishy - Actual bugs that will go wrong during runtime
2020-08-08 15:32:34 +00:00
static RefPtr<Process> from_pid(ProcessID);
Kernel: PID/PGID typing This compiles, and fixes two bugs: - setpgid() confusion (see previous commit) - tcsetpgrp() now allows to set a non-empty process group even if the group leader has already died. This makes Serenity slightly more POSIX-compatible.
2020-08-08 20:04:20 +00:00
static SessionID get_sid_from_pgid(ProcessGroupID pgid);
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Store process names as KString
2021-09-07 10:53:28 +00:00
StringView name() const { return m_name->view(); }
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
ProcessID pid() const { return m_protected_values.pid; }
SessionID sid() const { return m_protected_values.sid; }
bool is_session_leader() const { return sid().value() == pid().value(); }
Kernel: Distinguish between new and old process groups with equal pgids This does not add any behaviour change to the processes, but it ties a TTY to an active process group via TIOCSPGRP, and returns the TTY to the kernel when all processes in the process group die. Also makes the TTY keep a link to the original controlling process' parent (for SIGCHLD) instead of the process itself.
2020-08-15 19:13:19 +00:00
ProcessGroupID pgid() const { return m_pg ? m_pg->pgid() : 0; }
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
bool is_group_leader() const { return pgid().value() == pid().value(); }
Kernel: Strongly typed user & group ID's Prior to this change, both uid_t and gid_t were typedef'ed to `u32`. This made it easy to use them interchangeably. Let's not allow that. This patch adds UserID and GroupID using the AK::DistinctNumeric mechanism we've already been employing for pid_t/ProcessID.
2021-08-28 20:11:16 +00:00
Vector<GroupID> const& extra_gids() const { return m_protected_values.extra_gids; }
UserID euid() const { return m_protected_values.euid; }
GroupID egid() const { return m_protected_values.egid; }
UserID uid() const { return m_protected_values.uid; }
GroupID gid() const { return m_protected_values.gid; }
UserID suid() const { return m_protected_values.suid; }
GroupID sgid() const { return m_protected_values.sgid; }
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
ProcessID ppid() const { return m_protected_values.ppid; }
bool is_dumpable() const { return m_protected_values.dumpable; }
Kernel: Move process "dumpable" flag into protected data
2021-03-10 21:42:07 +00:00
void set_dumpable(bool);
Kernel+LibC: Introduce a "dumpable" flag for processes This new flag controls two things: - Whether the kernel will generate core dumps for the process - Whether the EUID:EGID should own the process's files in /proc Processes are automatically made non-dumpable when their EUID or EGID is changed, either via syscalls that specifically modify those ID's, or via sys$execve(), when a set-uid or set-gid program is executed. A process can change its own dumpable flag at any time by calling the new sys$prctl(PR_SET_DUMPABLE) syscall. Fixes #4504.
2020-12-25 17:27:42 +00:00
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
mode_t umask() const { return m_protected_values.umask; }
Kernel: Respect the process umask in open() and mkdir().
2019-02-22 01:39:13 +00:00
Kernel: Strongly typed user & group ID's Prior to this change, both uid_t and gid_t were typedef'ed to `u32`. This made it easy to use them interchangeably. Let's not allow that. This patch adds UserID and GroupID using the AK::DistinctNumeric mechanism we've already been employing for pid_t/ProcessID.
2021-08-28 20:11:16 +00:00
bool in_group(GroupID) const;
Add chown() syscall and a simple /bin/chown program.
2019-02-27 11:32:53 +00:00
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
// Breakable iteration functions
template<IteratorFunction<Process&> Callback>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
static void for_each(Callback);
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Process&> Callback>
Kernel: PID/PGID typing This compiles, and fixes two bugs: - setpgid() confusion (see previous commit) - tcsetpgrp() now allows to set a non-empty process group even if the group leader has already died. This makes Serenity slightly more POSIX-compatible.
2020-08-08 20:04:20 +00:00
static void for_each_in_pgrp(ProcessGroupID, Callback);
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Process&> Callback>
Add clang-format file Also run it across the whole tree to get everything using the One True Style. We don't yet run this in an automated fashion as it's a little slow, but there is a snippet to do so in makeall.sh.
2019-05-28 09:53:16 +00:00
void for_each_child(Callback);
Kernel: Move process thread lists into protected data
2021-03-11 13:12:55 +00:00
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Thread&> Callback>
Kernel: Move process thread lists into protected data
2021-03-11 13:12:55 +00:00
IterationDecision for_each_thread(Callback);
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Thread&> Callback>
IterationDecision for_each_thread(Callback callback) const;
Kernel: Add Process::try_for_each_thread() for fallible iteration This API will allow users to short circuit iteration and properly propagate errors.
2022-02-24 18:01:33 +00:00
ErrorOr<void> try_for_each_thread(Function<ErrorOr<void>(Thread const&)>) const;
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
// Non-breakable iteration functions
template<VoidFunction<Process&> Callback>
static void for_each(Callback);
template<VoidFunction<Process&> Callback>
static void for_each_in_pgrp(ProcessGroupID, Callback);
template<VoidFunction<Process&> Callback>
void for_each_child(Callback);
template<VoidFunction<Thread&> Callback>
IterationDecision for_each_thread(Callback);
template<VoidFunction<Thread&> Callback>
Kernel: Move process thread lists into protected data
2021-03-11 13:12:55 +00:00
IterationDecision for_each_thread(Callback callback) const;
Basic ^C interrupt implementation. For testing, I made cat put itself into a new process group. This should eventually be done by sh between fork() and exec().
2018-11-02 13:06:48 +00:00
Deallocate PTY's when they close. This required a fair bit of plumbing. The CharacterDevice::close() virtual will now be closed by ~FileDescriptor(), allowing device implementations to do custom cleanup at that point. One big problem remains: if the master PTY is closed before the slave PTY, we go into crashy land.
2019-01-30 17:26:19 +00:00
void die();
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
void finalize();
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
ThreadTracer* tracer() { return m_tracer.ptr(); }
bool is_traced() const { return !!m_tracer; }
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> start_tracing_from(ProcessID tracer);
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
void stop_tracing();
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void tracer_trap(Thread&, RegisterState const&);
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$emuctl();
ErrorOr<FlatPtr> sys$yield();
ErrorOr<FlatPtr> sys$sync();
ErrorOr<FlatPtr> sys$beep();
ErrorOr<FlatPtr> sys$get_process_name(Userspace<char*> buffer, size_t buffer_size);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$set_process_name(Userspace<char const*> user_name, size_t user_name_length);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$create_inode_watcher(u32 flags);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$inode_watcher_add_watch(Userspace<Syscall::SC_inode_watcher_add_watch_params const*> user_params);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$inode_watcher_remove_watch(int fd, int wd);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$dbgputstr(Userspace<char const*>, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$dump_backtrace();
ErrorOr<FlatPtr> sys$gettid();
ErrorOr<FlatPtr> sys$setsid();
ErrorOr<FlatPtr> sys$getsid(pid_t);
ErrorOr<FlatPtr> sys$setpgid(pid_t pid, pid_t pgid);
ErrorOr<FlatPtr> sys$getpgrp();
ErrorOr<FlatPtr> sys$getpgid(pid_t);
ErrorOr<FlatPtr> sys$getuid();
ErrorOr<FlatPtr> sys$getgid();
ErrorOr<FlatPtr> sys$geteuid();
ErrorOr<FlatPtr> sys$getegid();
ErrorOr<FlatPtr> sys$getpid();
ErrorOr<FlatPtr> sys$getppid();
ErrorOr<FlatPtr> sys$getresuid(Userspace<UserID*>, Userspace<UserID*>, Userspace<UserID*>);
ErrorOr<FlatPtr> sys$getresgid(Userspace<GroupID*>, Userspace<GroupID*>, Userspace<GroupID*>);
Kernel: Add getrusage() syscall Only the two timeval fields are maintained, as required by the POSIX standard.
2022-01-31 21:09:30 +00:00
ErrorOr<FlatPtr> sys$getrusage(int, Userspace<rusage*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$umask(mode_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$open(Userspace<Syscall::SC_open_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$close(int fd);
ErrorOr<FlatPtr> sys$read(int fd, Userspace<u8*>, size_t);
Kernel: Make sys${ftruncate,pread} take off_t as const pointer These syscalls don't write back to the off_t value (unlike sys$lseek) so let's take Userspace<off_t const*> instead of Userspace<off_t*>.
2021-12-17 07:34:27 +00:00
ErrorOr<FlatPtr> sys$pread(int fd, Userspace<u8*>, size_t, Userspace<off_t const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$write(int fd, Userspace<u8 const*>, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count);
ErrorOr<FlatPtr> sys$fstat(int fd, Userspace<stat*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$stat(Userspace<Syscall::SC_stat_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$lseek(int fd, Userspace<off_t*>, int whence);
Kernel: Make sys${ftruncate,pread} take off_t as const pointer These syscalls don't write back to the off_t value (unlike sys$lseek) so let's take Userspace<off_t const*> instead of Userspace<off_t*>.
2021-12-17 07:34:27 +00:00
ErrorOr<FlatPtr> sys$ftruncate(int fd, Userspace<off_t const*>);
Kernel+LibC: Add posix_fallocate syscall
2022-06-18 16:37:54 +00:00
ErrorOr<FlatPtr> sys$posix_fallocate(int fd, Userspace<off_t const*>, Userspace<off_t const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$kill(pid_t pid_or_pgid, int sig);
Use modern C++ attributes instead of __attribute__ voodoo. This is quite nice, although I wish [[gnu::always_inline]] implied inline. Also "gnu::" is kind of a wart, but whatcha gonna do.
2019-02-15 11:30:48 +00:00
[[noreturn]] void sys$exit(int status);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$sigreturn(RegisterState& registers);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$waitid(Userspace<Syscall::SC_waitid_params const*>);
ErrorOr<FlatPtr> sys$mmap(Userspace<Syscall::SC_mmap_params const*>);
ErrorOr<FlatPtr> sys$mremap(Userspace<Syscall::SC_mremap_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$munmap(Userspace<void*>, size_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$set_mmap_name(Userspace<Syscall::SC_set_mmap_name_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$mprotect(Userspace<void*>, size_t, int prot);
ErrorOr<FlatPtr> sys$madvise(Userspace<void*>, size_t, int advice);
ErrorOr<FlatPtr> sys$msyscall(Userspace<void*>);
Kernel+LibC: Add msync() system call This allows userspace to trigger a full (FIXME) flush of a shared file mapping to disk. We iterate over all the mapped pages in the VMObject and write them out to the underlying inode, one by one. This is rather naive, and there's lots of room for improvement. Note that shared file mappings are currently not possible since mmap() returns ENOTSUP for PROT_WRITE+MAP_SHARED. That restriction will be removed in a subsequent commit. :^)
2021-11-17 18:33:00 +00:00
ErrorOr<FlatPtr> sys$msync(Userspace<void*>, size_t, int flags);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$purge(int mode);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$poll(Userspace<Syscall::SC_poll_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$get_dir_entries(int fd, Userspace<void*>, size_t);
ErrorOr<FlatPtr> sys$getcwd(Userspace<char*>, size_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$chdir(Userspace<char const*>, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$fchdir(int fd);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$adjtime(Userspace<timeval const*>, Userspace<timeval*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$clock_gettime(clockid_t, Userspace<timespec*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$clock_settime(clockid_t, Userspace<timespec const*>);
ErrorOr<FlatPtr> sys$clock_nanosleep(Userspace<Syscall::SC_clock_nanosleep_params const*>);
Kernel/LibC: Implement posix syscall clock_getres()
2022-07-25 11:09:30 +00:00
ErrorOr<FlatPtr> sys$clock_getres(Userspace<Syscall::SC_clock_getres_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$gethostname(Userspace<char*>, size_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$sethostname(Userspace<char const*>, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$uname(Userspace<utsname*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$readlink(Userspace<Syscall::SC_readlink_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$fork(RegisterState&);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$execve(Userspace<Syscall::SC_execve_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$dup2(int old_fd, int new_fd);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$sigaction(int signum, Userspace<sigaction const*> act, Userspace<sigaction*> old_act);
ErrorOr<FlatPtr> sys$sigaltstack(Userspace<stack_t const*> ss, Userspace<stack_t*> old_ss);
ErrorOr<FlatPtr> sys$sigprocmask(int how, Userspace<sigset_t const*> set, Userspace<sigset_t*> old_set);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$sigpending(Userspace<sigset_t*>);
Kernel: Implement `sigsuspend` using a SignalBlocker `sigsuspend` was previously implemented using a poll on an empty set of file descriptors. However, this broke quite a few assumptions in `SelectBlocker`, as it verifies at least one file descriptor to be ready after waking up and as it relies on being notified by the file descriptor. A bare-bones `sigsuspend` may also be implemented by relying on any of the `sigwait` functions, but as `sigsuspend` features several (currently unimplemented) restrictions on how returns work, it is a syscall on its own.
2022-05-13 11:15:45 +00:00
ErrorOr<FlatPtr> sys$sigsuspend(Userspace<sigset_t const*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$sigtimedwait(Userspace<sigset_t const*>, Userspace<siginfo_t*>, Userspace<timespec const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$getgroups(size_t, Userspace<gid_t*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$setgroups(size_t, Userspace<gid_t const*>);
Kernel: Don't leak file descriptors in sys$pipe() If the final copy_to_user() call fails when writing the file descriptors to the output array, we have to make sure the file descriptors don't remain in the process file descriptor table. Otherwise they are basically leaked, as userspace is not aware of them. This matches the behavior of our sys$socketpair() implementation.
2022-08-16 18:35:32 +00:00
ErrorOr<FlatPtr> sys$pipe(Userspace<int*>, int flags);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$killpg(pid_t pgrp, int sig);
ErrorOr<FlatPtr> sys$seteuid(UserID);
ErrorOr<FlatPtr> sys$setegid(GroupID);
ErrorOr<FlatPtr> sys$setuid(UserID);
ErrorOr<FlatPtr> sys$setgid(GroupID);
ErrorOr<FlatPtr> sys$setreuid(UserID, UserID);
ErrorOr<FlatPtr> sys$setresuid(UserID, UserID, UserID);
ErrorOr<FlatPtr> sys$setresgid(GroupID, GroupID, GroupID);
ErrorOr<FlatPtr> sys$alarm(unsigned seconds);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$access(Userspace<char const*> pathname, size_t path_length, int mode);
Kernel+LibC+LibCore: Pass fcntl extra argument as pointer-sized variable The extra argument to fcntl is a pointer in the case of F_GETLK/F_SETLK and we were pulling out a u32, leading to pointer truncation on x86_64. Among other things, this fixes Assistant on x86_64 :^)
2022-07-02 23:02:45 +00:00
ErrorOr<FlatPtr> sys$fcntl(int fd, int cmd, uintptr_t extra_arg);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$ioctl(int fd, unsigned request, FlatPtr arg);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$mkdir(Userspace<char const*> pathname, size_t path_length, mode_t mode);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$times(Userspace<tms*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$utime(Userspace<char const*> pathname, size_t path_length, Userspace<const struct utimbuf*>);
Kernel+LibC+VFS: Implement utimensat(3) Create POSIX utimensat() library call and corresponding system call to update file access and modification times.
2022-05-02 20:26:10 +00:00
ErrorOr<FlatPtr> sys$utimensat(Userspace<Syscall::SC_utimensat_params const*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$link(Userspace<Syscall::SC_link_params const*>);
Kernel+LibC+LibCore: Implement the unlinkat(2) syscall
2022-02-10 11:30:33 +00:00
ErrorOr<FlatPtr> sys$unlink(int dirfd, Userspace<char const*> pathname, size_t path_length, int flags);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$symlink(Userspace<Syscall::SC_symlink_params const*>);
ErrorOr<FlatPtr> sys$rmdir(Userspace<char const*> pathname, size_t path_length);
ErrorOr<FlatPtr> sys$mount(Userspace<Syscall::SC_mount_params const*>);
ErrorOr<FlatPtr> sys$umount(Userspace<char const*> mountpoint, size_t mountpoint_length);
Kernel+LibC+LibCore+UE: Implement `fchmodat(2)` This function is an extended version of `chmod(2)` that lets one control whether to dereference symlinks, and specify a file descriptor to a directory that will be used as the base for relative paths.
2022-01-11 15:51:34 +00:00
ErrorOr<FlatPtr> sys$chmod(Userspace<Syscall::SC_chmod_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$fchmod(int fd, mode_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$chown(Userspace<Syscall::SC_chown_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$fchown(int fd, UserID, GroupID);
ErrorOr<FlatPtr> sys$fsync(int fd);
ErrorOr<FlatPtr> sys$socket(int domain, int type, int protocol);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$bind(int sockfd, Userspace<sockaddr const*> addr, socklen_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$listen(int sockfd, int backlog);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$accept4(Userspace<Syscall::SC_accept4_params const*>);
ErrorOr<FlatPtr> sys$connect(int sockfd, Userspace<sockaddr const*>, socklen_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$shutdown(int sockfd, int how);
ErrorOr<FlatPtr> sys$sendmsg(int sockfd, Userspace<const struct msghdr*>, int flags);
ErrorOr<FlatPtr> sys$recvmsg(int sockfd, Userspace<struct msghdr*>, int flags);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$getsockopt(Userspace<Syscall::SC_getsockopt_params const*>);
ErrorOr<FlatPtr> sys$setsockopt(Userspace<Syscall::SC_setsockopt_params const*>);
ErrorOr<FlatPtr> sys$getsockname(Userspace<Syscall::SC_getsockname_params const*>);
ErrorOr<FlatPtr> sys$getpeername(Userspace<Syscall::SC_getpeername_params const*>);
ErrorOr<FlatPtr> sys$socketpair(Userspace<Syscall::SC_socketpair_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$sched_setparam(pid_t pid, Userspace<const struct sched_param*>);
ErrorOr<FlatPtr> sys$sched_getparam(pid_t pid, Userspace<struct sched_param*>);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$create_thread(void* (*)(void*), Userspace<Syscall::SC_create_thread_params const*>);
Kernel: Make sure we free the thread stack on thread exit This adds two new arguments to the thread_exit system call which let a thread unmap an arbitrary VM range on thread exit. LibPthread uses this functionality to unmap the thread stack. Fixes #7267.
2021-05-28 09:20:22 +00:00
[[noreturn]] void sys$exit_thread(Userspace<void*>, Userspace<void*>, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$join_thread(pid_t tid, Userspace<void**> exit_value);
ErrorOr<FlatPtr> sys$detach_thread(pid_t tid);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$set_thread_name(pid_t tid, Userspace<char const*> buffer, size_t buffer_size);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size);
ErrorOr<FlatPtr> sys$kill_thread(pid_t tid, int signal);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$rename(Userspace<Syscall::SC_rename_params const*>);
ErrorOr<FlatPtr> sys$mknod(Userspace<Syscall::SC_mknod_params const*>);
ErrorOr<FlatPtr> sys$realpath(Userspace<Syscall::SC_realpath_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$getrandom(Userspace<void*>, size_t, unsigned int);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$getkeymap(Userspace<Syscall::SC_getkeymap_params const*>);
ErrorOr<FlatPtr> sys$setkeymap(Userspace<Syscall::SC_setkeymap_params const*>);
Kernel: Fixed argument passing for profiling_enable syscall Arguments larger than 32bit need to be passed as a pointer on a 32bit architectures. sys$profiling_enable has u64 event_mask argument, which means that it needs to be passed as an pointer. Previously upper 32bits were filled by garbage.
2022-02-18 21:12:35 +00:00
ErrorOr<FlatPtr> sys$profiling_enable(pid_t, Userspace<u64 const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$profiling_disable(pid_t);
ErrorOr<FlatPtr> sys$profiling_free_buffer(pid_t);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$futex(Userspace<Syscall::SC_futex_params const*>);
ErrorOr<FlatPtr> sys$pledge(Userspace<Syscall::SC_pledge_params const*>);
ErrorOr<FlatPtr> sys$unveil(Userspace<Syscall::SC_unveil_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2);
ErrorOr<FlatPtr> sys$perf_register_string(Userspace<char const*>, size_t);
ErrorOr<FlatPtr> sys$get_stack_bounds(Userspace<FlatPtr*> stack_base, Userspace<size_t*> stack_size);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$ptrace(Userspace<Syscall::SC_ptrace_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$sendfd(int sockfd, int fd);
ErrorOr<FlatPtr> sys$recvfd(int sockfd, int options);
ErrorOr<FlatPtr> sys$sysconf(int name);
ErrorOr<FlatPtr> sys$disown(ProcessID);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$allocate_tls(Userspace<char const*> initial_data, size_t);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$prctl(int option, FlatPtr arg1, FlatPtr arg2);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$set_coredump_metadata(Userspace<Syscall::SC_set_coredump_metadata_params const*>);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$anon_create(size_t, int options);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> sys$statvfs(Userspace<Syscall::SC_statvfs_params const*> user_params);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<FlatPtr> sys$fstatvfs(int fd, statvfs* buf);
ErrorOr<FlatPtr> sys$map_time_page();
Kernel: Add a simple shared memory API for two processes only. And use this to implement shared bitmaps between WindowServer and clients.
2019-02-16 11:13:43 +00:00
Kernel: Remove SmapDisablers in sys$getsockname() and sys$getpeername() Instead use the user/kernel copy helpers to only copy the minimum stuff needed from to/from userspace. Based on work started by Brian Gianforcaro.
2020-01-27 20:11:36 +00:00
template<bool sockname, typename Params>
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> get_sock_or_peer_name(Params const&);
Kernel: Remove SmapDisablers in sys$getsockname() and sys$getpeername() Instead use the user/kernel copy helpers to only copy the minimum stuff needed from to/from userspace. Based on work started by Brian Gianforcaro.
2020-01-27 20:11:36 +00:00
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
static void initialize();
Kernel: Fix Process::crash assuming 32-bit mode
2021-06-28 16:32:25 +00:00
[[noreturn]] void crash(int signal, FlatPtr ip, bool out_of_memory = false);
Kernel: Resolve clang-tidy readability-make-member-function-const ... In files included from Kernel/Thread.cpp or Kernel/Process.cpp Some places the warning is suppressed, because we do not want a const object do have non-const access to the returned sub-object.
2021-10-31 21:54:39 +00:00
[[nodiscard]] siginfo_t wait_info() const;
Actually destroy tasks after they crash.
2018-10-17 22:26:30 +00:00
Virtual consoles kinda work! We now make three VirtualConsoles at boot: tty0, tty1, and tty2. We launch an instance of /bin/sh in each one. You switch between them with Alt+1/2/3 How very very cool :^)
2018-10-30 14:33:37 +00:00
const TTY* tty() const { return m_tty; }
Kernel: Reduce header dependencies of Process and Thread
2020-02-16 01:01:42 +00:00
void set_tty(TTY*);
Virtual consoles kinda work! We now make three VirtualConsoles at boot: tty0, tty1, and tty2. We launch an instance of /bin/sh in each one. You switch between them with Alt+1/2/3 How very very cool :^)
2018-10-30 14:33:37 +00:00
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 19:17:35 +00:00
u32 m_ticks_in_user { 0 };
u32 m_ticks_in_kernel { 0 };
Implement basic support for times(). The kernel now bills processes for time spent in kernelspace and userspace separately. The accounting is forwarded to the parent process in reap(). This makes the "time" builtin in bash work.
2018-12-03 00:12:26 +00:00
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 19:17:35 +00:00
u32 m_ticks_in_user_for_dead_children { 0 };
u32 m_ticks_in_kernel_for_dead_children { 0 };
Implement basic support for times(). The kernel now bills processes for time spent in kernelspace and userspace separately. The accounting is forwarded to the parent process in reap(). This makes the "time" builtin in bash work.
2018-12-03 00:12:26 +00:00
Kernel: Put Process's current directory in a SpinlockProtected Also let's call it "current_directory" instead of "cwd" everywhere.
2022-03-07 16:56:25 +00:00
NonnullRefPtr<Custody> current_directory();
Kernel: Expose process executable paths in /proc/all
2020-12-26 23:54:13 +00:00
Custody* executable() { return m_executable.ptr(); }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Custody const* executable() const { return m_executable.ptr(); }
Add a VFS::absolutePath(InodeIdentifier). This is pretty inefficient for ext2fs. We walk the entire block group containing the inode, searching through every directory for an entry referencing this inode. It might be a good idea to cache this information somehow. I'm not sure how often we'll be searching for it. Obviously there are multiple caching layers missing in the file system.
2018-10-28 11:20:25 +00:00
Kernel: Expose maximum argument limit in sysconf Move the definitions for maximum argument and environment size to Process.h from execve.cpp. This allows sysconf(_SC_ARG_MAX) to return the actual argument maximum of 128 KiB to userspace.
2022-02-13 19:07:51 +00:00
static constexpr size_t max_arguments_size = Thread::default_userspace_stack_size / 8;
static constexpr size_t max_environment_size = Thread::default_userspace_stack_size / 8;
Kernel: Use KString all the way in sys$execve() This patch converts all the usage of AK::String around sys$execve() to using KString instead, allowing us to catch and propagate OOM errors. It also required changing the kernel CommandLine helper class to return a vector of KString for the userspace init program arguments.
2021-09-09 09:36:40 +00:00
NonnullOwnPtrVector<KString> const& arguments() const { return m_arguments; };
NonnullOwnPtrVector<KString> const& environment() const { return m_environment; };
Kernel: Store process arguments and environment in coredumps Currently they're only pushed onto the stack but not easily accessible from the Process class, so this adds a Vector<String> for both.
2021-01-15 19:21:03 +00:00
Kernel: Perform exec-into-new-image directly in sys$execve() This ensures that everything allocated on the stack in Process::exec() gets cleaned up. We had a few leaks related to the parsing of shebang (#!) executables that get fixed by this.
2022-01-13 22:12:51 +00:00
ErrorOr<void> exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, Thread*& new_main_thread, u32& prev_flags, int recursion_depth = 0);
Implement fork()! This is quite cool! The syscall entry point plumbs the register dump down to sys$fork(), which uses it to set up the child process's TSS in order to resume execution right after the int 0x80 fork() call. :^) This works pretty well, although there is some problem with the kernel alias mappings used to clone the parent process's regions. If I disable the MM::release_page_directory() code, there's no problem. Probably there's a premature freeing of a physical page somehow.
2018-11-02 19:41:58 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<LoadResult> load(NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header);
Kernel: Add ability to load interpreter instead of main program When the main executable needs an interpreter, we load the requested interpreter program, and pass to it an open file decsriptor to the main executable via the auxiliary vector. Note that we do not allocate a TLS region for the interpreter.
2020-10-10 09:13:21 +00:00
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
bool is_superuser() const { return euid() == 0; }
Add some basic setgroups(), getgroups() and initgroups(). Also teach /bin/id to print the user's supplemental groups.
2018-11-07 00:38:51 +00:00
AK: Rename the common integer typedefs to make it obvious what they are. These types can be picked up by including <AK/Types.h>: * u8, u16, u32, u64 (unsigned) * i8, i16, i32, i64 (signed)
2019-07-03 19:17:35 +00:00
void terminate_due_to_signal(u8 signal);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> send_signal(u8 signal, Process* sender);
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
u8 termination_signal() const { return m_protected_values.termination_signal; }
Kernel: Fill some siginfo and ucontext fields on SA_SIGINFO There's no reason to fill in any of these fields if SA_SIGINFO is not given, as the signal handler won't be reading from them at all.
2022-02-26 11:59:31 +00:00
u8 termination_status() const { return m_protected_values.termination_status; }
Kernel+LibELF: Store termination signal in coredump ProcessInfo
2021-01-03 20:46:38 +00:00
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^)
2020-07-30 21:38:15 +00:00
u16 thread_count() const
{
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
return m_protected_values.thread_count.load(AK::MemoryOrder::memory_order_relaxed);
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^)
2020-07-30 21:38:15 +00:00
}
Kernel: Get rid of "main thread" concept The idea of all processes reliably having a main thread was nice in some ways, but cumbersome in others. More importantly, it didn't match up with POSIX thread semantics, so let's move away from it. This thread gets rid of Process::main_thread() and you now we just have a bunch of Thread objects floating around each Process. When the finalizer nukes the last Thread in a Process, it will also tear down the Process. There's a bunch of more things to fix around this, but this is where we get started :^)
2019-12-22 10:35:02 +00:00
Kernel: Rename Lock to Mutex Let's be explicit about what kind of lock this is meant to be.
2021-07-17 19:09:51 +00:00
Mutex& big_lock() { return m_big_lock; }
Mutex& ptrace_lock() { return m_ptrace_lock; }
Kernel: Add a blunt big process lock. We can't have multiple threads in the same process running in the kernel at the same time, so let's have a per-process lock that threads have to acquire on syscall entry/exit (and yield while blocked.)
2019-04-01 18:02:05 +00:00
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
bool has_promises() const { return m_protected_values.has_promises; }
Kernel: Resolve clang-tidy readability-implicit-bool-conversion warnings ... In files included from Kernel/Process.cpp and Kernel/Thread.cpp
2021-11-06 21:06:08 +00:00
bool has_promised(Pledge pledge) const { return (m_protected_values.promises & (1U << (u32)pledge)) != 0; }
ping: Use pledge()
2020-01-11 19:48:43 +00:00
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^)
2020-07-30 21:38:15 +00:00
VeilState veil_state() const
{
Kernel: Put Process unveil state in a SpinlockProtected container This makes path resolution safe to perform without holding the big lock.
2022-03-07 20:23:08 +00:00
return m_unveil_data.with([&](auto const& unveil_data) { return unveil_data.state; });
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^)
2020-07-30 21:38:15 +00:00
}
Kernel: Add a basic implementation of unveil() This syscall is a complement to pledge() and adds the same sort of incremental relinquishing of capabilities for filesystem access. The first call to unveil() will "drop a veil" on the process, and from now on, only unveiled parts of the filesystem are visible to it. Each call to unveil() specifies a path to either a directory or a file along with permissions for that path. The permissions are a combination of the following: - r: Read access (like the "rpath" promise) - w: Write access (like the "wpath" promise) - x: Execute access - c: Create/remove access (like the "cpath" promise) Attempts to open a path that has not been unveiled with fail with ENOENT. If the unveiled path lacks sufficient permissions, it will fail with EACCES. Like pledge(), subsequent calls to unveil() with the same path can only remove permissions, not add them. Once you call unveil(nullptr, nullptr), the veil is locked, and it's no longer possible to unveil any more paths for the process, ever. This concept comes from OpenBSD, and their implementation does various things differently, I'm sure. This is just a first implementation for SerenityOS, and we'll keep improving on it as we go. :^)
2020-01-20 21:12:04 +00:00
Kernel: Put Process unveil state in a SpinlockProtected container This makes path resolution safe to perform without holding the big lock.
2022-03-07 20:23:08 +00:00
struct UnveilData {
explicit UnveilData(UnveilNode&& p)
: paths(move(p))
{
}
VeilState state { VeilState::None };
UnveilNode paths;
};
auto& unveil_data() { return m_unveil_data; }
auto const& unveil_data() const { return m_unveil_data; }
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^)
2020-07-30 21:38:15 +00:00
bool wait_for_tracer_at_next_execve() const
{
return m_wait_for_tracer_at_next_execve;
}
void set_wait_for_tracer_at_next_execve(bool val)
{
m_wait_for_tracer_at_next_execve = val;
}
ptrace: Add PT_SETREGS PT_SETTREGS sets the regsiters of the traced thread. It can only be used when the tracee is stopped. Also, refactor ptrace. The implementation was getting long and cluttered the alraedy large Process.cpp file. This commit moves the bulk of the implementation to Kernel/Ptrace.cpp, and factors out peek & poke to separate methods of the Process class.
2020-04-07 15:23:37 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> peek_user_data(Span<u8> destination, Userspace<u8 const*> address);
ErrorOr<FlatPtr> peek_user_data(Userspace<FlatPtr const*> address);
Kernel+LibC: Fix ptrace for 64-bit This makes the types used in the PT_PEEK and PT_POKE actions suitable for 64-bit platforms as well.
2021-11-19 14:13:07 +00:00
ErrorOr<void> poke_user_data(Userspace<FlatPtr*> address, FlatPtr data);
ptrace: Add PT_SETREGS PT_SETTREGS sets the regsiters of the traced thread. It can only be used when the tracee is stopped. Also, refactor ptrace. The implementation was getting long and cluttered the alraedy large Process.cpp file. This commit moves the bulk of the implementation to Kernel/Ptrace.cpp, and factors out peek & poke to separate methods of the Process class.
2020-04-07 15:23:37 +00:00
Kernel: disown should unblock any potential waiters This is necessary because if a process changes the state to Stopped or resumes from that state, a wait entry is created in the parent process. So, if a child process does this before disown is called, we need to clear those entries to avoid leaking references/zombies that won't be cleaned up until the former parent exits. This also should solve an even more unlikely corner case where another thread is waiting on a pid that is being disowned by another thread.
2020-12-09 02:04:05 +00:00
void disowned_by_waiter(Process& process);
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
void unblock_waiters(Thread::WaitBlocker::UnblockFlags, u8 signal = 0);
Kernel: Rename some BlockerSets to foo_blocker_set Cleanup after renaming BlockCondition to BlockerSet.
2021-08-22 23:22:38 +00:00
Thread::WaitBlockerSet& wait_blocker_set() { return m_wait_blocker_set; }
Kernel: Move block condition evaluation out of the Scheduler This makes the Scheduler a lot leaner by not having to evaluate block conditions every time it is invoked. Instead evaluate them as the states change, and unblock threads at that point. This also implements some more waitid/waitpid/wait features and behavior. For example, WUNTRACED and WNOWAIT are now supported. And wait will now not return EINTR when SIGCHLD is delivered at the same time.
2020-11-29 23:05:27 +00:00
Kernel: Store coredump metadata properties as KStrings This patch also replaces the HashMap previously used to store coredump properties with a plain AK::Array.
2021-08-05 21:43:10 +00:00
template<typename Callback>
Everywhere: Make JSON serialization fallible This allows us to eliminate a major source of infallible allocation in the Kernel, as well as lay down the groundwork for OOM fallibility in userland.
2022-02-24 18:08:48 +00:00
ErrorOr<void> for_each_coredump_property(Callback callback) const
Kernel: Store coredump metadata properties as KStrings This patch also replaces the HashMap previously used to store coredump properties with a plain AK::Array.
2021-08-05 21:43:10 +00:00
{
Kernel: Remove big lock from `sys$set_coredump_metadata` The only requirement for this syscall is to make Process::m_coredump_properties SpinlockProtected.
2022-04-09 17:30:20 +00:00
return m_coredump_properties.with([&](auto const& coredump_properties) -> ErrorOr<void> {
for (auto const& property : coredump_properties) {
if (property.key && property.value)
TRY(callback(*property.key, *property.value));
}
return {};
});
Kernel: Store coredump metadata properties as KStrings This patch also replaces the HashMap previously used to store coredump properties with a plain AK::Array.
2021-08-05 21:43:10 +00:00
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr<KString> value);
ErrorOr<void> try_set_coredump_property(StringView key, StringView value);
Kernel: Add sys$set_coredump_metadata() syscall This can be used by applications to store information (key/value pairs) likely useful for debugging, which will then be embedded in the coredump.
2020-12-30 14:19:57 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
NonnullRefPtrVector<Thread> const& threads_for_coredump(Badge<Coredump>) const { return m_threads_for_coredump; }
Kernel: Generate coredump backtraces from "threads for coredump" list This broke with the change that gave each process a list of its own threads. Since threads are removed slightly earlier from that list during process teardown, we're not able to use it for generating coredump backtraces. Fortunately we have the "threads for coredump" list for just this purpose. :^)
2021-01-28 07:41:18 +00:00
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
PerformanceEventBuffer* perf_events() { return m_perf_event_buffer; }
Kernel: Add const variant of Process::perf_events() This lets us get rid of some const_casts.
2021-09-07 15:35:56 +00:00
PerformanceEventBuffer const* perf_events() const { return m_perf_event_buffer; }
Kernel+Profiler: Make profiling per-process and without core dumps This patch merges the profiling functionality in the kernel with the performance events mechanism. A profiler sample is now just another perf event, rather than a dedicated thing. Since perf events were already per-process, this now makes profiling per-process as well. Processes with perf events would already write out a perfcore.PID file to the current directory on death, but since we may want to profile a process and then let it continue running, recorded perf events can now be accessed at any time via /proc/PID/perf_events. This patch also adds information about process memory regions to the perfcore JSON format. This removes the need to supply a core dump to the Profiler app for symbolication, and so the "profiler coredump" mechanism is removed entirely. There's still a hard limit of 4MB worth of perf events per process, so this is by no means a perfect final design, but it's a nice step forward for both simplicity and stability. Fixes #4848 Fixes #4849
2021-01-11 08:52:18 +00:00
Kernel: Rename Process::space() => Process::address_space() We commonly talk about "a process's address space" so let's nudge the code towards matching how we talk about it. :^)
2021-08-06 11:59:22 +00:00
Memory::AddressSpace& address_space() { return *m_space; }
Memory::AddressSpace const& address_space() const { return *m_space; }
Kernel: Add a way to specify which memory regions can make syscalls This patch adds sys$msyscall() which is loosely based on an OpenBSD mechanism for preventing syscalls from non-blessed memory regions. It works similarly to pledge and unveil, you can call it as many times as you like, and when you're finished, you call it with a null pointer and it will stop accepting new regions from then on. If a syscall later happens and doesn't originate from one of the previously blessed regions, the kernel will simply crash the process.
2021-02-02 18:56:11 +00:00
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
VirtualAddress signal_trampoline() const { return m_protected_values.signal_trampoline; }
Kernel: Map signal trampoline into each process's address space The signal trampoline was previously in kernelspace memory, but with a special exception to make it user-accessible. This patch moves it into each process's regular address space so we can stop supporting user-allowed memory above 0xc0000000.
2021-02-13 23:53:53 +00:00
Kernel: Handle promise violations in the syscall handler Previously we would crash the process immediately when a promise violation was found during a syscall. This is error prone, as we don't unwind the stack. This means that in certain cases we can leak resources, like an OwnPtr / RefPtr tracked on the stack. Or even leak a lock acquired in a ScopeLockLocker. To remedy this situation we move the promise violation handling to the syscall handler, right before we return to user space. This allows the code to follow the normal unwind path, and grantees there is no longer any cleanup that needs to occur. The Process::require_promise() and Process::require_no_promises() functions were modified to return ErrorOr<void> so we enforce that the errors are always propagated by the caller.
2021-12-29 09:11:45 +00:00
ErrorOr<void> require_promise(Pledge);
ErrorOr<void> require_no_promises() const;
Kernel: Move pledge verification into Process member functions REQUIRE_PROMISE and REQUIRE_NO_PROMISES were macros for some reason, and used all over the place. This patch adds require_promise(Pledge) and require_no_promises() to Process and makes the macros call these on the current process instead of inlining code everywhere.
2021-09-04 20:26:06 +00:00
Kernel: Make mmap validation functions return ErrorOr<void>
2022-02-25 01:24:57 +00:00
ErrorOr<void> validate_mmap_prot(int prot, bool map_stack, bool map_anonymous, Memory::Region const* region = nullptr) const;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> validate_inode_mmap_prot(int prot, Inode const& inode, bool map_shared) const;
Kernel: Move mmap validation functions to Process
2022-03-10 00:53:40 +00:00
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
private:
More paging stuff. The test userspace process now runs at linear address 0x300000 which is mapped to a dynamically allocated page from the MemoryManager. Cool!
2018-10-18 11:05:00 +00:00
friend class MemoryManager;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
friend class Scheduler;
Refactor the virtual memory object model a bit: Process now has a number of Regions. Each Region is backed by a VMObject. A VMObject can be file-backed or anonymous. These can be shared.
2018-11-08 13:35:30 +00:00
friend class Region;
Kernel: Add PerformanceManager static class, move perf event APIs there The current method of emitting performance events requires a bit of boiler plate at every invocation, as well as having to ignore the return code which isn't used outside of the perf event syscall. This change attempts to clean that up by exposing high level API's that can be used around the code base.
2021-05-07 05:29:19 +00:00
friend class PerformanceManager;
More paging stuff. The test userspace process now runs at linear address 0x300000 which is mapped to a dynamically allocated page from the MemoryManager. Cool!
2018-10-18 11:05:00 +00:00
Kernel: Keep a list of threads per Process This allow us to iterate only the threads of the process.
2021-01-23 06:24:33 +00:00
bool add_thread(Thread&);
bool remove_thread(Thread&);
Kernel: Put Process's current directory in a SpinlockProtected Also let's call it "current_directory" instead of "cwd" everywhere.
2022-03-07 16:56:25 +00:00
Process(NonnullOwnPtr<KString> name, UserID, GroupID, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> current_directory, RefPtr<Custody> executable, TTY* tty, UnveilNode unveil_tree);
static ErrorOr<NonnullRefPtr<Process>> try_create(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, UserID, GroupID, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> current_directory = nullptr, RefPtr<Custody> executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr);
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> attach_resources(NonnullOwnPtr<Memory::AddressSpace>&&, RefPtr<Thread>& first_thread, Process* fork_parent);
Kernel: PID/TID typing This compiles, and contains exactly the same bugs as before. The regex 'FIXME: PID/' should reveal all markers that I left behind, including: - Incomplete conversion - Issues or things that look fishy - Actual bugs that will go wrong during runtime
2020-08-08 15:32:34 +00:00
static ProcessID allocate_pid();
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +00:00
Kernel: Allow process with multiple threads to call exec and exit This allows a process wich has more than 1 thread to call exec, even from a thread. This kills all the other threads, but it won't wait for them to finish, just makes sure that they are not in a running/runable state. In the case where a thread does exec, the new program PID will be the thread TID, to keep the PID == TID in the new process. This introduces a new function inside the Process class, kill_threads_except_self which is called on exit() too (exit with multiple threads wasn't properly working either). Inside the Lock class, there is the need for a new function, clear_waiters, which removes all the waiters from the Process::big_lock. This is needed since after a exit/exec, there should be no other threads waiting for this lock, the threads should be simply killed. Only queued threads should wait for this lock at this point, since blocked threads are handled in set_should_die.
2020-02-18 12:28:28 +00:00
void kill_threads_except_self();
void kill_all_threads();
Kernel: Surface errors when generating a process core dump :^)
2021-11-29 11:06:33 +00:00
ErrorOr<void> dump_core();
Kernel: Make Process::dump_perfcore OOM-fallible using KString
2022-01-12 21:21:08 +00:00
ErrorOr<void> dump_perfcore();
Kernel: Better handling of allocation failure in profiling If we can't allocate a PerformanceEventBuffer to store the profiling events, we now fail sys$profiling_enable() and sys$perf_event() with ENOMEM instead of carrying on with a broken buffer.
2021-03-02 15:55:54 +00:00
bool create_perf_events_buffer_if_needed();
Kernel: Add a syscall to clear the profiling buffer While profiling all processes the profile buffer lives forever. Once you have copied the profile to disk, there's no need to keep it in memory. This syscall surfaces the ability to clear that buffer.
2021-04-19 04:10:05 +00:00
void delete_perf_events_buffer();
Kernel: Allow process with multiple threads to call exec and exit This allows a process wich has more than 1 thread to call exec, even from a thread. This kills all the other threads, but it won't wait for them to finish, just makes sure that they are not in a running/runable state. In the case where a thread does exec, the new program PID will be the thread TID, to keep the PID == TID in the new process. This introduces a new function inside the Process class, kill_threads_except_self which is called on exit() too (exit with multiple threads wasn't properly working either). Inside the Lock class, there is the need for a new function, clear_waiters, which removes all the waiters from the Process::big_lock. This is needed since after a exit/exec, there should be no other threads waiting for this lock, the threads should be simply killed. Only queued threads should wait for this lock at this point, since blocked threads are handled in set_should_die.
2020-02-18 12:28:28 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header);
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<FlatPtr> do_write(OpenFileDescription&, UserOrKernelBuffer const&, size_t);
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Fix TOCTOU in fstatvfs In particular, fstatvfs used to assume that a file that was earlier opened using some path will forever be at that path. This is wrong, and in the meantime new mounts and new filesystems could take up the filename or directories, leading to a completely inaccurate result. This commit improves the situation: - All filesystem information is now always accurate. - The mount flags *might* be erroneously zero, if the custody for the open file is not available. I don't know when that might happen, but it is definitely not the typical case.
2021-11-06 23:09:48 +00:00
ErrorOr<FlatPtr> do_statvfs(FileSystem const& path, Custody const*, statvfs* buf);
Kernel: Add statvfs & fstatvfs Syscalls These syscalls fill a statvfs struct with various data about the mount on the VFS.
2021-05-19 09:31:43 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size);
Kernel: Tighten up exec/do_exec and allow for PT_INTERP iterpreters This patch changes how exec() figures out which program image to actually load. Previously, we opened the path to our main executable in find_shebang_interpreter_for_executable, read the first page (or less, if the file was smaller) and then decided whether to recurse with the interpreter instead. We then then re-opened the main executable in do_exec. However, since we now want to parse the ELF header and Program Headers of an elf image before even doing any memory region work, we can change the way this whole process works. We open the file and read (up to) the first page in exec() itself, then pass just the page and the amount read to find_shebang_interpreter_for_executable. Since we now have that page and the FileDescription for the main executable handy, we can do a few things. First, validate the ELF header and ELF program headers for any shenanigans. ELF32 Little Endian i386 only, please. Second, we can grab the PT_INTERP interpreter from any ET_DYN files, and open that guy right away if it exists. Finally, we can pass the main executable's and optionally the PT_INTERP interpreter's file descriptions down to do_exec and not have to feel guilty about opening the file twice. In do_exec, we now have a choice. Are we going to load the main executable, or the interpreter? We could load both, but it'll be way easier for the inital pass on the RTLD if we only load the interpreter. Then it can load the main executable itself like any old shared object, just, the one with main in it :). Later on we can load both of them into memory and the RTLD can relocate itself before trying to do anything. The way it's written now the RTLD will get dibs on its requested virtual addresses being the actual virtual addresses.
2020-01-11 01:28:02 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> do_kill(Process&, int signal);
ErrorOr<void> do_killpg(ProcessGroupID pgrp, int signal);
ErrorOr<void> do_killall(int signal);
ErrorOr<void> do_killself(int signal);
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<siginfo_t> do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options);
Kernel+LibC: Add sys$waitid(), and make sys$waitpid() wrap it sys$waitid() takes an explicit description of whether it's waiting for a single process with the given PID, all of the children, a group, etc., and returns its info as a siginfo_t. It also doesn't automatically imply WEXITED, which clears up the confusion in the kernel.
2020-02-05 16:42:43 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
static ErrorOr<NonnullOwnPtr<KString>> get_syscall_path_argument(Userspace<char const*> user_path, size_t path_length);
static ErrorOr<NonnullOwnPtr<KString>> get_syscall_path_argument(Syscall::StringArgument const&);
Kernel: Pass path+length to mkdir(), rmdir() and chmod()
2020-01-06 10:05:59 +00:00
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
bool has_tracee_thread(ProcessID tracer_pid);
Kernel: Add 'ptrace' syscall This commit adds a basic implementation of the ptrace syscall, which allows one process (the tracer) to control another process (the tracee). While a process is being traced, it is stopped whenever a signal is received (other than SIGCONT). The tracer can start tracing another thread with PT_ATTACH, which causes the tracee to stop. From there, the tracer can use PT_CONTINUE to continue the execution of the tracee, or use other request codes (which haven't been implemented yet) to modify the state of the tracee. Additional request codes are PT_SYSCALL, which causes the tracee to continue exection but stop at the next entry or exit from a syscall, and PT_GETREGS which fethces the last saved register set of the tracee (can be used to inspect syscall arguments and return value). A special request code is PT_TRACE_ME, which is issued by the tracee and causes it to stop when it calls execve and wait for the tracer to attach.
2020-03-28 08:47:16 +00:00
Kernel: Do a POSIX-correct signal handler reset on exec
2022-07-02 09:42:17 +00:00
void clear_signal_handlers_for_exec();
Kernel: Some futex improvements This adds support for FUTEX_WAKE_OP, FUTEX_WAIT_BITSET, FUTEX_WAKE_BITSET, FUTEX_REQUEUE, and FUTEX_CMP_REQUEUE, as well well as global and private futex and absolute/relative timeouts against the appropriate clock. This also changes the implementation so that kernel resources are only used when a thread is blocked on a futex. Global futexes are implemented as offsets in VMObjects, so that different processes can share a futex against the same VMObject despite potentially being mapped at different virtual addresses.
2020-12-22 06:21:58 +00:00
void clear_futex_queues_on_exec();
Kernel: Clean up sys$futex and add support for cross-process futexes
2022-07-13 22:25:35 +00:00
ErrorOr<GlobalFutexKey> get_futex_key(FlatPtr user_address, bool shared);
Kernel+LibC: Implement sigaltstack() This is required for compiling wine for serenity
2021-10-28 20:33:41 +00:00
ErrorOr<void> remap_range_as_stack(FlatPtr address, size_t size);
Kernel/Profiling: Add profiling to read syscall Syscalls to read can now be profiled, allowing us to monitor filesystem usage by different applications.
2021-12-04 12:26:13 +00:00
ErrorOr<FlatPtr> read_impl(int fd, Userspace<u8*> buffer, size_t size);
Kernel: Steer away from heap allocations for ProcFS process data Instead, use more static patterns to acquire that sort of data.
2021-08-10 17:51:28 +00:00
public:
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
NonnullRefPtr<ProcessProcFSTraits> procfs_traits() const { return *m_procfs_traits; }
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<void> procfs_get_fds_stats(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_perf_events(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_unveil_stats(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_pledge_stats(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_virtual_memory_stats(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_binary_link(KBufferBuilder& builder) const;
ErrorOr<void> procfs_get_current_work_directory_link(KBufferBuilder& builder) const;
Kernel: Create /proc/pid/cmdline to expose process arguments in procfs In typical serenity style, they are just a JSON array
2022-06-13 05:04:35 +00:00
ErrorOr<void> procfs_get_command_line(KBufferBuilder& builder) const;
Kernel: Steer away from heap allocations for ProcFS process data Instead, use more static patterns to acquire that sort of data.
2021-08-10 17:51:28 +00:00
mode_t binary_link_required_mode() const;
Kernel: Remove useless return value from procfs_get_thread_stack
2022-01-15 22:04:24 +00:00
ErrorOr<void> procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const;
Kernel: Use DistinctNumeric for filesystem ID's This patch adds the FileSystemID type, which is a distinct u32. This prevents accidental conversion from arbitrary integers.
2021-11-18 14:11:31 +00:00
ErrorOr<void> traverse_stacks_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<NonnullRefPtr<Inode>> lookup_stacks_directory(ProcFS const&, StringView name) const;
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<size_t> procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const;
Kernel: Use DistinctNumeric for filesystem ID's This patch adds the FileSystemID type, which is a distinct u32. This prevents accidental conversion from arbitrary integers.
2021-11-18 14:11:31 +00:00
ErrorOr<void> traverse_file_descriptions_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<NonnullRefPtr<Inode>> lookup_file_descriptions_directory(ProcFS const&, StringView name) const;
Kernel: Add /proc/{pid}/children to ProcFS This exposes the child processes for a process as a directory of symlinks to the respective /proc entries for each child. This makes for an easier and possibly more efficient way to find and count a process's children. Previously the only method was to parse the entire /proc/all JSON file.
2022-05-04 15:22:18 +00:00
ErrorOr<NonnullRefPtr<Inode>> lookup_children_directory(ProcFS const&, StringView name) const;
ErrorOr<void> traverse_children_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const;
ErrorOr<size_t> procfs_get_child_proccess_link(ProcessID child_pid, KBufferBuilder& builder) const;
Kernel: Steer away from heap allocations for ProcFS process data Instead, use more static patterns to acquire that sort of data.
2021-08-10 17:51:28 +00:00
private:
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
inline PerformanceEventBuffer* current_perf_events_buffer()
{
Kernel: Make sure we only log profiling events when m_profiling is true Previously the process' m_profiling flag was ignored for all event types other than CPU samples. The kfree tracing code relies on temporarily disabling tracing during exec. This didn't work for per-process profiles and would instead panic. This updates the profiling code so that the m_profiling flag isn't ignored.
2021-05-23 20:16:30 +00:00
if (g_profiling_all_threads)
return g_global_perf_events;
Kernel: Avoid else after return in Process and ThreadSafeRefCounted
2021-10-31 22:51:08 +00:00
if (m_profiling)
Kernel: Make sure we only log profiling events when m_profiling is true Previously the process' m_profiling flag was ignored for all event types other than CPU samples. The kfree tracing code relies on temporarily disabling tracing during exec. This didn't work for per-process profiles and would instead panic. This updates the profiling code so that the m_profiling flag isn't ignored.
2021-05-23 20:16:30 +00:00
return m_perf_event_buffer.ptr();
Kernel: Avoid else after return in Process and ThreadSafeRefCounted
2021-10-31 22:51:08 +00:00
return nullptr;
Kernel+Profiler: Improve profiling subsystem This turns the perfcore format into more a log than it was before, which lets us properly log process, thread and region creation/destruction. This also makes it unnecessary to dump the process' regions every time it is scheduled like we did before. Incidentally this also fixes 'profile -c' because we previously ended up incorrectly dumping the parent's region map into the profile data. Log-based mmap support enables profiling shared libraries which are loaded at runtime, e.g. via dlopen(). This enables profiling both the parent and child process for programs which use execve(). Previously we'd discard the profiling data for the old process. The Profiler tool has been updated to not treat thread IDs as process IDs anymore. This enables support for processes with more than one thread. Also, there's a new widget to filter which process should be displayed.
2021-04-25 21:42:36 +00:00
}
Kernel: Make Process::m_list_node non-mutable The mutable keyword was not achieving anything, so let's remove it.
2022-01-16 16:06:33 +00:00
IntrusiveListNode<Process> m_list_node;
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
Kernel: Store process names as KString
2021-09-07 10:53:28 +00:00
NonnullOwnPtr<KString> m_name;
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
Kernel: Rename Memory::Space => Memory::AddressSpace
2021-08-06 11:57:39 +00:00
OwnPtr<Memory::AddressSpace> m_space;
Kernel: Factor address space management out of the Process class This patch adds Space, a class representing a process's address space. - Each Process has a Space. - The Space owns the PageDirectory and all Regions in the Process. This allows us to reorganize sys$execve() so that it constructs and populates a new Space fully before committing to it. Previously, we would construct the new address space while still running in the old one, and encountering an error meant we had to do tedious and error-prone rollback. Those problems are now gone, replaced by what's hopefully a set of much smaller problems and missing cleanups. :^)
2021-02-08 14:45:40 +00:00
Kernel: Distinguish between new and old process groups with equal pgids This does not add any behaviour change to the processes, but it ties a TTY to an active process group via TIOCSPGRP, and returns the TTY to the kernel when all processes in the process group die. Also makes the TTY keep a link to the original controlling process' parent (for SIGCHLD) instead of the process itself.
2020-08-15 19:13:19 +00:00
RefPtr<ProcessGroup> m_pg;
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
Kernel: Fix race causing modifying a Process to fail with a panic The ProtectedDataMutationScope cannot blindly assume that there is only exactly one thread at a time that may want to unprotect the Process. Most of the time the big lock guaranteed this, but there are some cases such as finalization (among others) where this is not necessarily guaranteed. This fixes random panics due to access violations when the ProtectedDataMutationScope protects the Process instance while another is still modifying it. Fixes #8512
2021-07-07 16:29:19 +00:00
AtomicEdgeAction<u32> m_protected_data_refs;
Kernel: Move select Process members into protected memory Process member variable like m_euid are very valuable targets for kernel exploits and until now they have been writable at all times. This patch moves m_euid along with a whole bunch of other members into a new Process::ProtectedData struct. This struct is remapped as read-only memory whenever we don't need to write to it. This means that a kernel write primitive is no longer enough to overwrite a process's effective UID, you must first unprotect the protected data where the UID is stored. :^)
2021-03-10 18:59:46 +00:00
void protect_data();
void unprotect_data();
Kernel+LibC: Implement seteuid() and friends! Add seteuid()/setegid() under _POSIX_SAVED_IDS semantics, which also requires adding suid and sgid to Process, and changing setuid()/setgid() to honor these semantics. The exact semantics aren't specified by POSIX and differ between different Unix implementations. This patch makes serenity follow FreeBSD. The 2002 USENIX paper "Setuid Demystified" explains the differences well. In addition to seteuid() and setegid() this also adds setreuid()/setregid() and setresuid()/setresgid(), and the accessors getresuid()/getresgid(). Also reorder uid/euid functions so that they are the same order everywhere (namely, the order that geteuid()/getuid() already have).
2020-06-17 12:58:00 +00:00
Kernel: Change wait blocking to Process-only blocking This prevents zombies created by multi-threaded applications and brings our model back to closer to what other OSs do. This also means that SIGSTOP needs to halt all threads, and SIGCONT needs to resume those threads.
2020-12-09 04:18:45 +00:00
OwnPtr<ThreadTracer> m_tracer;
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
public:
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
class OpenFileDescriptionAndFlags {
Kernel: Turn Process::FileDescriptionAndFlags into a proper class
2020-07-30 21:50:31 +00:00
public:
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
bool is_valid() const { return !m_description.is_null(); }
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
bool is_allocated() const { return m_is_allocated; }
void allocate()
{
VERIFY(!m_is_allocated);
VERIFY(!is_valid());
m_is_allocated = true;
}
void deallocate()
{
VERIFY(m_is_allocated);
VERIFY(!is_valid());
m_is_allocated = false;
}
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
OpenFileDescription* description() { return m_description; }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
OpenFileDescription const* description() const { return m_description; }
Kernel: Turn Process::FileDescriptionAndFlags into a proper class
2020-07-30 21:50:31 +00:00
u32 flags() const { return m_flags; }
void set_flags(u32 flags) { m_flags = flags; }
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
void clear();
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
void set(NonnullRefPtr<OpenFileDescription>&&, u32 flags = 0);
Kernel: Turn Process::FileDescriptionAndFlags into a proper class
2020-07-30 21:50:31 +00:00
private:
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
RefPtr<OpenFileDescription> m_description;
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
bool m_is_allocated { false };
Kernel: Turn Process::FileDescriptionAndFlags into a proper class
2020-07-30 21:50:31 +00:00
u32 m_flags { 0 };
Add close-on-exec flag for file descriptors. I was surprised to find that dup()'ed fds don't share the close-on-exec flag. That means it has to be stored separately from the FileDescriptor object.
2018-11-13 00:36:31 +00:00
};
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
class ScopedDescriptionAllocation;
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
class OpenFileDescriptions {
AK_MAKE_NONCOPYABLE(OpenFileDescriptions);
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
AK_MAKE_NONMOVABLE(OpenFileDescriptions);
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
friend class Process;
public:
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
OpenFileDescriptions() { }
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ALWAYS_INLINE OpenFileDescriptionAndFlags const& operator[](size_t i) const { return at(i); }
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
ALWAYS_INLINE OpenFileDescriptionAndFlags& operator[](size_t i) { return at(i); }
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<void> try_clone(Kernel::Process::OpenFileDescriptions const& other)
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
{
AK: Make Vector::try_* functions return ErrorOr<void> Instead of signalling allocation failure with a bool return value (false), we now use ErrorOr<void> and return ENOMEM as appropriate. This allows us to use TRY() and MUST() with Vector. :^)
2021-11-10 10:55:37 +00:00
TRY(try_resize(other.m_fds_metadatas.size()));
Kernel: Make cloning of FileDescriptions OOM safe
2021-08-13 08:37:07 +00:00
for (size_t i = 0; i < other.m_fds_metadatas.size(); ++i) {
m_fds_metadatas[i] = other.m_fds_metadatas[i];
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
return {};
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
OpenFileDescriptionAndFlags const& at(size_t i) const;
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
OpenFileDescriptionAndFlags& at(size_t i);
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
OpenFileDescriptionAndFlags const* get_if_valid(size_t i) const;
OpenFileDescriptionAndFlags* get_if_valid(size_t i);
Kernel: Add a Process::FileDescriptions::get_if_valid(index) API Note that this is not the same as ::at(index), which has a different precondition ("allocated" vs "valid").
2021-08-16 02:02:48 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void enumerate(Function<void(OpenFileDescriptionAndFlags const&)>) const;
ErrorOr<void> try_enumerate(Function<ErrorOr<void>(OpenFileDescriptionAndFlags const&)>) const;
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
void change_each(Function<void(OpenFileDescriptionAndFlags&)>);
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<ScopedDescriptionAllocation> allocate(int first_candidate_fd = 0);
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
size_t open_count() const;
AK: Make Vector::try_* functions return ErrorOr<void> Instead of signalling allocation failure with a bool return value (false), we now use ErrorOr<void> and return ENOMEM as appropriate. This allows us to use TRY() and MUST() with Vector. :^)
2021-11-10 10:55:37 +00:00
ErrorOr<void> try_resize(size_t size) { return m_fds_metadatas.try_resize(size); }
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
Kernel: Make OpenFileDescriptions::max_open() static and constexpr This method was just returning a static constexpr member variable verbatim, so there's no point requiring a member function to observe its value.
2021-10-31 22:45:01 +00:00
static constexpr size_t max_open()
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
{
Kernel: Make OpenFileDescriptions::max_open() static and constexpr This method was just returning a static constexpr member variable verbatim, so there's no point requiring a member function to observe its value.
2021-10-31 22:45:01 +00:00
return s_max_open_file_descriptors;
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
}
void clear()
{
m_fds_metadatas.clear();
}
Kernel: Replace KResult and KResultOr<T> with Error and ErrorOr<T> We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
2021-11-07 23:51:39 +00:00
ErrorOr<NonnullRefPtr<OpenFileDescription>> open_file_description(int fd) const;
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
private:
Kernel: Make OpenFileDescriptions::max_open() static and constexpr This method was just returning a static constexpr member variable verbatim, so there's no point requiring a member function to observe its value.
2021-10-31 22:45:01 +00:00
static constexpr size_t s_max_open_file_descriptors { FD_SETSIZE };
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
Vector<OpenFileDescriptionAndFlags> m_fds_metadatas;
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change.
2021-06-22 18:22:17 +00:00
};
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
class ScopedDescriptionAllocation {
AK_MAKE_NONCOPYABLE(ScopedDescriptionAllocation);
public:
ScopedDescriptionAllocation() = default;
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
ScopedDescriptionAllocation(int tracked_fd, OpenFileDescriptionAndFlags* description)
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
: fd(tracked_fd)
, m_description(description)
{
}
ScopedDescriptionAllocation(ScopedDescriptionAllocation&& other)
: fd(other.fd)
{
// Take over the responsibility of tracking to deallocation.
swap(m_description, other.m_description);
}
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
ScopedDescriptionAllocation& operator=(ScopedDescriptionAllocation&& other)
{
if (this != &other) {
m_description = exchange(other.m_description, nullptr);
fd = exchange(other.fd, -1);
}
return *this;
}
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
~ScopedDescriptionAllocation()
{
if (m_description && m_description->is_allocated() && !m_description->is_valid()) {
m_description->deallocate();
}
}
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
int fd { -1 };
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
private:
Kernel: Rename FileDescription => OpenFileDescription Dr. POSIX really calls these "open file description", not just "file description", so let's call them exactly that. :^)
2021-09-07 11:39:11 +00:00
OpenFileDescriptionAndFlags* m_description { nullptr };
Kernel: Track allocated FileDescriptionAndFlag elements in each Process The way the Process::FileDescriptions::allocate() API works today means that two callers who allocate back to back without associating a FileDescription with the allocated FD, will receive the same FD and thus one will stomp over the other. Naively tracking which FileDescriptions are allocated and moving onto the next would introduce other bugs however, as now if you "allocate" a fd and then return early further down the control flow of the syscall you would leak that fd. This change modifies this behavior by tracking which descriptions are allocated and then having an RAII type to "deallocate" the fd if the association is not setup the end of it's scope.
2021-07-28 06:59:24 +00:00
};
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
class ProcessProcFSTraits : public ProcFSExposedComponent {
public:
Kernel: Use try_make_weak_ptr() instead of make_weak_ptr()
2022-02-13 19:21:14 +00:00
static ErrorOr<NonnullRefPtr<ProcessProcFSTraits>> try_create(Badge<Process>, WeakPtr<Process> process)
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
{
Kernel: Use try_make_weak_ptr() instead of make_weak_ptr()
2022-02-13 19:21:14 +00:00
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcessProcFSTraits(move(process)));
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
}
virtual InodeIndex component_index() const override;
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
virtual ErrorOr<NonnullRefPtr<Inode>> to_inode(ProcFS const& procfs_instance) const override;
Kernel: Use DistinctNumeric for filesystem ID's This patch adds the FileSystemID type, which is a distinct u32. This prevents accidental conversion from arbitrary integers.
2021-11-18 14:11:31 +00:00
virtual ErrorOr<void> traverse_as_directory(FileSystemID, Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
virtual mode_t required_mode() const override { return 0555; }
Kernel: Strongly typed user & group ID's Prior to this change, both uid_t and gid_t were typedef'ed to `u32`. This made it easy to use them interchangeably. Let's not allow that. This patch adds UserID and GroupID using the AK::DistinctNumeric mechanism we've already been employing for pid_t/ProcessID.
2021-08-28 20:11:16 +00:00
virtual UserID owner_user() const override;
virtual GroupID owner_group() const override;
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
private:
Kernel: Use try_make_weak_ptr() instead of make_weak_ptr()
2022-02-13 19:21:14 +00:00
explicit ProcessProcFSTraits(WeakPtr<Process> process)
: m_process(move(process))
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
{
}
// NOTE: We need to weakly hold on to the process, because otherwise
// we would be creating a reference cycle.
WeakPtr<Process> m_process;
};
Kernel: Switch process file descriptor table from spinlock to mutex There's no reason for this to use a spinlock. Instead, let's allow threads to block if someone else is using the descriptor table.
2022-01-29 00:29:07 +00:00
MutexProtected<OpenFileDescriptions>& fds() { return m_fds; }
MutexProtected<OpenFileDescriptions> const& fds() const { return m_fds; }
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
ErrorOr<NonnullRefPtr<OpenFileDescription>> open_file_description(int fd)
{
Kernel: Switch process file descriptor table from spinlock to mutex There's no reason for this to use a spinlock. Instead, let's allow threads to block if someone else is using the descriptor table.
2022-01-29 00:29:07 +00:00
return m_fds.with_shared([fd](auto& fds) { return fds.open_file_description(fd); });
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
}
ErrorOr<NonnullRefPtr<OpenFileDescription>> open_file_description(int fd) const
{
Kernel: Switch process file descriptor table from spinlock to mutex There's no reason for this to use a spinlock. Instead, let's allow threads to block if someone else is using the descriptor table.
2022-01-29 00:29:07 +00:00
return m_fds.with_shared([fd](auto& fds) { return fds.open_file_description(fd); });
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
}
ErrorOr<ScopedDescriptionAllocation> allocate_fd()
{
Kernel: Switch process file descriptor table from spinlock to mutex There's no reason for this to use a spinlock. Instead, let's allow threads to block if someone else is using the descriptor table.
2022-01-29 00:29:07 +00:00
return m_fds.with_exclusive([](auto& fds) { return fds.allocate(); });
Kernel: Convert process file descriptor table to a SpinlockProtected Instead of manually locking in the various member functions of Process::OpenFileDescriptions, simply wrap it in a SpinlockProtected.
2022-01-29 00:22:28 +00:00
}
Kernel: Introduce the new ProcFS design The new ProcFS design consists of two main parts: 1. The representative ProcFS class, which is derived from the FS class. The ProcFS and its inodes are much more lean - merely 3 classes to represent the common type of inodes - regular files, symbolic links and directories. They're backed by a ProcFSExposedComponent object, which is responsible for the functional operation behind the scenes. 2. The backend of the ProcFS - the ProcFSComponentsRegistrar class and all derived classes from the ProcFSExposedComponent class. These together form the entire backend and handle all the functions you can expect from the ProcFS. The ProcFSExposedComponent derived classes split to 3 types in the manner of lifetime in the kernel: 1. Persistent objects - this category includes all basic objects, like the root folder, /proc/bus folder, main blob files in the root folders, etc. These objects are persistent and cannot die ever. 2. Semi-persistent objects - this category includes all PID folders, and subdirectories to the PID folders. It also includes exposed objects like the unveil JSON'ed blob. These object are persistent as long as the the responsible process they represent is still alive. 3. Dynamic objects - this category includes files in the subdirectories of a PID folder, like /proc/PID/fd/* or /proc/PID/stacks/*. Essentially, these objects are always created dynamically and when no longer in need after being used, they're deallocated. Nevertheless, the new allocated backend objects and inodes try to use the same InodeIndex if possible - this might change only when a thread dies and a new thread is born with a new thread stack, or when a file descriptor is closed and a new one within the same file descriptor number is opened. This is needed to actually be able to do something useful with these objects. The new design assures that many ProcFS instances can be used at once, with one backend for usage for all instances.
2021-06-12 01:23:58 +00:00
private:
Kernel: Rename SpinLock => Spinlock
2021-08-21 23:37:17 +00:00
SpinlockProtected<Thread::ListInProcess>& thread_list() { return m_thread_list; }
SpinlockProtected<Thread::ListInProcess> const& thread_list() const { return m_thread_list; }
Kernel: Port process thread lists to SpinLockProtectedValue I had to move the thread list out of the protected base area of Process so that it could live with its lock (which needs to be mutable). Ideally it would live in the protected area, so maybe we can figure out a way to do that later.
2021-08-07 11:28:18 +00:00
Kernel: Require lock rank for Spinlock construction All users which relied on the default constructor use a None lock rank for now. This will make it easier to in the future remove LockRank and actually annotate the ranks by searching for None.
2022-08-18 19:46:28 +00:00
SpinlockProtected<Thread::ListInProcess> m_thread_list { LockRank::None };
Rework process states to make a bit more sense. Processes are either alive (with many substates), dead or forgiven. A dead process is forgiven when the parent waitpid()s on it. Dead orphans are also forgiven. There's a lot of work to be done around this.
2018-11-07 17:30:59 +00:00
Kernel: Switch process file descriptor table from spinlock to mutex There's no reason for this to use a spinlock. Instead, let's allow threads to block if someone else is using the descriptor table.
2022-01-29 00:29:07 +00:00
MutexProtected<OpenFileDescriptions> m_fds;
More paging stuff. The test userspace process now runs at linear address 0x300000 which is mapped to a dynamically allocated page from the MemoryManager. Cool!
2018-10-18 11:05:00 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
bool const m_is_kernel_process;
Kernel: Ignore subsequent calls to Process::die It's possible that another thread might try to exit the process just about the same time another thread does the same, or a crash happens. Also, we may not be able to kill all other threads instantly as they may be blocked in the kernel (though in this case they would get killed before ever returning back to user mode. So keep track of whether Process::die was already called and ignore it on subsequent calls. Fixes #8485
2021-07-13 23:15:24 +00:00
Atomic<State> m_state { State::Running };
Kernel: Implement a simple process time profiler The kernel now supports basic profiling of all the threads in a process by calling profiling_enable(pid_t). You finish the profiling by calling profiling_disable(pid_t). This all works by recording thread stacks when the timer interrupt fires and the current thread is in a process being profiled. Note that symbolication is deferred until profiling_disable() to avoid adding more noise than necessary to the profile. A simple "/bin/profile" command is included here that can be used to start/stop profiling like so: $ profile 10 on ... wait ... $ profile 10 off After a profile has been recorded, it can be fetched in /proc/profile There are various limits (or "bugs") on this mechanism at the moment: - Only one process can be profiled at a time. - We allocate 8MB for the samples, if you use more space, things will not work, and probably break a bit. - Things will probably fall apart if the profiled process dies during profiling, or while extracing /proc/profile
2019-12-11 19:36:56 +00:00
bool m_profiling { false };
Kernel: Specify default memory order for some non-synchronizing Atomics
2021-01-03 23:58:50 +00:00
Atomic<bool, AK::MemoryOrder::memory_order_relaxed> m_is_stopped { false };
Everywhere: Core dump => Coredump We all know what a coredump is, and it feels more natural to refer to it as a coredump (most code already does), so let's be consistent.
2021-08-22 12:51:04 +00:00
bool m_should_generate_coredump { false };
Kernel: Reorder some Process members to shrink the class by 8 bytes
2019-08-08 12:56:50 +00:00
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr<Custody> m_executable;
Kernel: Put Process's current directory in a SpinlockProtected Also let's call it "current_directory" instead of "cwd" everywhere.
2022-03-07 16:56:25 +00:00
SpinlockProtected<RefPtr<Custody>> m_current_directory;
Add a "pwd" utility to userland. It's implemented as a separate process. How cute is that. Tasks now have a current working directory. Spawned tasks inherit their parent task's working directory. Currently everyone just uses "/" as there's no way to chdir().
2018-10-24 12:28:22 +00:00
Kernel: Use KString all the way in sys$execve() This patch converts all the usage of AK::String around sys$execve() to using KString instead, allowing us to catch and propagate OOM errors. It also required changing the kernel CommandLine helper class to return a vector of KString for the userspace init program arguments.
2021-09-09 09:36:40 +00:00
NonnullOwnPtrVector<KString> m_arguments;
NonnullOwnPtrVector<KString> m_environment;
Kernel: Store process arguments and environment in coredumps Currently they're only pushed onto the stack but not easily accessible from the Process class, so this adds a Vector<String> for both.
2021-01-15 19:21:03 +00:00
Kernel: A running process should keep its TTY alive It's not safe to use a raw pointer for Process::m_tty. A pseudoterminal pair will disappear when file descriptors are closed, and we'd end up looking dangly. Just use a RefPtr.
2019-11-06 15:52:54 +00:00
RefPtr<TTY> m_tty;
Start working on virtual consoles/TTYs. This is a mess right now, but I'd rather commit as I go.
2018-10-30 12:59:29 +00:00
Kernel: Move Kernel/Memory/ code into Kernel::Memory namespace
2021-08-06 11:49:36 +00:00
WeakPtr<Memory::Region> m_master_tls_region;
Kernel: Support thread-local storage This patch adds support for TLS according to the x86 System V ABI. Each thread gets a thread-specific memory region, and the GS segment register always points _to a pointer_ to the thread-specific memory. In other words, to access thread-local variables, userspace programs start by dereferencing the pointer at [gs:0]. The Process keeps a master copy of the TLS segment that new threads should use, and when a new thread is created, they get a copy of it. It's basically whatever the PT_TLS program header in the ELF says.
2019-09-07 13:50:44 +00:00
size_t m_master_tls_size { 0 };
size_t m_master_tls_alignment { 0 };
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
Mutex m_big_lock { "Process"sv, Mutex::MutexBehavior::BigLock };
Mutex m_ptrace_lock { "ptrace"sv };
Kernel: Implement the alarm() syscall.
2019-06-07 09:30:07 +00:00
Kernel: Use TimerQueue for SIGALRM
2020-12-01 22:44:52 +00:00
RefPtr<Timer> m_alarm_timer;
Kernel+ProcessManager: Let processes have an icon and show it in the table. Processes can now have an icon assigned, which is essentially a 16x16 RGBA32 bitmap exposed as a shared buffer ID. You set the icon ID by calling set_process_icon(int) and the icon ID will be exposed through /proc/all. To make this work, I added a mechanism for making shared buffers globally accessible. For safety reasons, each app seals the icon buffer before making it global. Right now the first call to GWindow::set_icon() is what determines the process icon. We'll probably change this in the future. :^)
2019-07-29 05:26:01 +00:00
Kernel: Put Process unveil state in a SpinlockProtected container This makes path resolution safe to perform without holding the big lock.
2022-03-07 20:23:08 +00:00
SpinlockProtected<UnveilData> m_unveil_data;
Kernel: Add a basic implementation of unveil() This syscall is a complement to pledge() and adds the same sort of incremental relinquishing of capabilities for filesystem access. The first call to unveil() will "drop a veil" on the process, and from now on, only unveiled parts of the filesystem are visible to it. Each call to unveil() specifies a path to either a directory or a file along with permissions for that path. The permissions are a combination of the following: - r: Read access (like the "rpath" promise) - w: Write access (like the "wpath" promise) - x: Execute access - c: Create/remove access (like the "cpath" promise) Attempts to open a path that has not been unveiled with fail with ENOENT. If the unveiled path lacks sufficient permissions, it will fail with EACCES. Like pledge(), subsequent calls to unveil() with the same path can only remove permissions, not add them. Once you call unveil(nullptr, nullptr), the veil is locked, and it's no longer possible to unveil any more paths for the process, ever. This concept comes from OpenBSD, and their implementation does various things differently, I'm sure. This is just a first implementation for SerenityOS, and we'll keep improving on it as we go. :^)
2020-01-20 21:12:04 +00:00
Kernel: Start working on a syscall for logging performance events This patch introduces sys$perf_event() with two event types: - PERF_EVENT_MALLOC - PERF_EVENT_FREE After the first call to sys$perf_event(), a process will begin keeping these events in a buffer. When the process dies, that buffer will be written out to "perfcore" in the current directory unless that filename is already taken. This is probably not the best way to do this, but it's a start and will make it possible to start doing memory allocation profiling. :^)
2020-02-02 19:26:27 +00:00
OwnPtr<PerformanceEventBuffer> m_perf_event_buffer;
Kernel: Allow multiple inspectors of a process (in /proc) Replace Process::m_being_inspected with an inspector reference count. This prevents an assertion from firing when inspecting the same process in /proc from multiple processes at the same time. It was trivially reproducible by opening multiple FileManagers.
2020-02-17 12:29:49 +00:00
Kernel: Add 'ptrace' syscall This commit adds a basic implementation of the ptrace syscall, which allows one process (the tracer) to control another process (the tracee). While a process is being traced, it is stopped whenever a signal is received (other than SIGCONT). The tracer can start tracing another thread with PT_ATTACH, which causes the tracee to stop. From there, the tracer can use PT_CONTINUE to continue the execution of the tracee, or use other request codes (which haven't been implemented yet) to modify the state of the tracee. Additional request codes are PT_SYSCALL, which causes the tracee to continue exection but stop at the next entry or exit from a syscall, and PT_GETREGS which fethces the last saved register set of the tracee (can be used to inspect syscall arguments and return value). A special request code is PT_TRACE_ME, which is issued by the tracee and causes it to stop when it calls execve and wait for the tracer to attach.
2020-03-28 08:47:16 +00:00
// This member is used in the implementation of ptrace's PT_TRACEME flag.
// If it is set to true, the process will stop at the next execve syscall
// and wait for a tracer to attach.
bool m_wait_for_tracer_at_next_execve { false };
Kernel: Move block condition evaluation out of the Scheduler This makes the Scheduler a lot leaner by not having to evaluate block conditions every time it is invoked. Instead evaluate them as the states change, and unblock threads at that point. This also implements some more waitid/waitpid/wait features and behavior. For example, WUNTRACED and WNOWAIT are now supported. And wait will now not return EINTR when SIGCHLD is delivered at the same time.
2020-11-29 23:05:27 +00:00
Kernel: Rename some BlockerSets to foo_blocker_set Cleanup after renaming BlockCondition to BlockerSet.
2021-08-22 23:22:38 +00:00
Thread::WaitBlockerSet m_wait_blocker_set;
Kernel: Add sys$set_coredump_metadata() syscall This can be used by applications to store information (key/value pairs) likely useful for debugging, which will then be embedded in the coredump.
2020-12-30 14:19:57 +00:00
Kernel: Store coredump metadata properties as KStrings This patch also replaces the HashMap previously used to store coredump properties with a plain AK::Array.
2021-08-05 21:43:10 +00:00
struct CoredumpProperty {
OwnPtr<KString> key;
OwnPtr<KString> value;
};
Kernel: Require lock rank for Spinlock construction All users which relied on the default constructor use a None lock rank for now. This will make it easier to in the future remove LockRank and actually annotate the ranks by searching for None.
2022-08-18 19:46:28 +00:00
SpinlockProtected<Array<CoredumpProperty, 4>> m_coredump_properties { LockRank::None };
Kernel: Generate coredump backtraces from "threads for coredump" list This broke with the change that gave each process a list of its own threads. Since threads are removed slightly earlier from that list during process teardown, we're not able to use it for generating coredump backtraces. Fortunately we have the "threads for coredump" list for just this purpose. :^)
2021-01-28 07:41:18 +00:00
NonnullRefPtrVector<Thread> m_threads_for_coredump;
Kernel: Switch Process to InstrusiveList from InlineLinkedList
2021-06-06 21:40:03 +00:00
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
mutable RefPtr<ProcessProcFSTraits> m_procfs_traits;
Kernel: Move signal handlers from being thread state to process state POSIX requires that sigaction() and friends set a _process-wide_ signal handler, so move signal handlers and flags inside Process. This also fixes a "pid/tid confusion" FIXME, as we can now send the signal to the process and let that decide which thread should get the signal (which is the thread with tid==pid, but that's now the Process's problem). Note that each thread still retains its signal mask, as that is local to each thread.
2022-02-24 18:55:49 +00:00
struct SignalActionData {
VirtualAddress handler_or_sigaction;
int flags { 0 };
u32 mask { 0 };
};
Array<SignalActionData, NSIG> m_signal_action_data;
Kernel: Move ProcFS related overrides in Process to ProcessProcFSTraits This allows us to 1) let go of the Process when an inode is ref'ing for ProcFSExposedComponent related reasons, and 2) change our ref/unref implementation.
2021-08-14 12:43:34 +00:00
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
static_assert(sizeof(ProtectedValues) < (PAGE_SIZE));
alignas(4096) ProtectedValues m_protected_values;
u8 m_protected_values_padding[PAGE_SIZE - sizeof(ProtectedValues)];
Kernel: Switch Process to InstrusiveList from InlineLinkedList
2021-06-06 21:40:03 +00:00
public:
AK+Everywhere: Reduce the number of template parameters of IntrusiveList This makes the user-facing type only take the node member pointer, and lets the compiler figure out the other needed types from that.
2021-09-09 12:00:59 +00:00
using List = IntrusiveListRelaxedConst<&Process::m_list_node>;
Kernel: Port Process to ListedRefCounted
2021-12-28 22:46:21 +00:00
static SpinlockProtected<Process::List>& all_instances();
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work.
2018-10-16 09:01:38 +00:00
};
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
// Note: Process object should be 2 pages of 4096 bytes each.
// It's not expected that the Process object will expand further because the first
// page is used for all unprotected values (which should be plenty of space for them).
// The second page is being used exclusively for write-protected values.
Kernel: Switch static_asserts of a type size to AK::AssertSize This will provide better debug ability when the size comparison fails.
2021-09-05 07:57:53 +00:00
static_assert(AssertSize<Process, (PAGE_SIZE * 2)>());
Kernel/Process: Move protected values to the end of the object The compiler can re-order the structure (class) members if that's necessary, so if we make Process to inherit from ProcFSExposedComponent, even if the declaration is to inherit first from ProcessBase, then from ProcFSExposedComponent and last from Weakable<Process>, the members of class ProcFSExposedComponent (including the Ref-counted parts) are the first members of the Process class. This problem made it impossible to safely use the current toggling method with the write-protection bit on the ProcessBase members, so instead of inheriting from it, we make its members the last ones in the Process class so we can safely locate and modify the corresponding page write protection bit of these values. We make sure that the Process class doesn't expand beyond 8192 bytes and the protected values are always aligned on a page boundary.
2021-08-07 19:30:06 +00:00
Kernel: Rename SpinLock => Spinlock
2021-08-21 23:37:17 +00:00
extern RecursiveSpinlock g_profiling_lock;
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Process&> Callback>
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
inline void Process::for_each(Callback callback)
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_INTERRUPTS_DISABLED();
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Process::all_instances().with([&](auto const& list) {
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
for (auto it = list.begin(); it != list.end();) {
auto& process = *it;
++it;
if (callback(process) == IterationDecision::Break)
break;
}
});
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
}
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Process&> Callback>
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
inline void Process::for_each_child(Callback callback)
{
Kernel: PID/TID typing This compiles, and contains exactly the same bugs as before. The regex 'FIXME: PID/' should reveal all markers that I left behind, including: - Incomplete conversion - Issues or things that look fishy - Actual bugs that will go wrong during runtime
2020-08-08 15:32:34 +00:00
ProcessID my_pid = pid();
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Process::all_instances().with([&](auto const& list) {
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
for (auto it = list.begin(); it != list.end();) {
auto& process = *it;
++it;
if (process.ppid() == my_pid || process.has_tracee_thread(pid())) {
if (callback(process) == IterationDecision::Break)
break;
}
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
}
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
});
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
}
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Thread&> Callback>
Kernel: Keep a list of threads per Process This allow us to iterate only the threads of the process.
2021-01-23 06:24:33 +00:00
inline IterationDecision Process::for_each_thread(Callback callback) const
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
{
Kernel: Port process thread lists to SpinLockProtectedValue I had to move the thread list out of the protected base area of Process so that it could live with its lock (which needs to be mutable). Ideally it would live in the protected area, so maybe we can figure out a way to do that later.
2021-08-07 11:28:18 +00:00
return thread_list().with([&](auto& thread_list) -> IterationDecision {
for (auto& thread : thread_list) {
IterationDecision decision = callback(thread);
if (decision != IterationDecision::Continue)
return decision;
}
return IterationDecision::Continue;
});
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
}
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Thread&> Callback>
Kernel: Move process thread lists into protected data
2021-03-11 13:12:55 +00:00
inline IterationDecision Process::for_each_thread(Callback callback)
{
Kernel: Port process thread lists to SpinLockProtectedValue I had to move the thread list out of the protected base area of Process so that it could live with its lock (which needs to be mutable). Ideally it would live in the protected area, so maybe we can figure out a way to do that later.
2021-08-07 11:28:18 +00:00
return thread_list().with([&](auto& thread_list) -> IterationDecision {
for (auto& thread : thread_list) {
IterationDecision decision = callback(thread);
if (decision != IterationDecision::Continue)
return decision;
}
return IterationDecision::Continue;
});
Kernel: Move process thread lists into protected data
2021-03-11 13:12:55 +00:00
}
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<IteratorFunction<Process&> Callback>
Kernel: PID/PGID typing This compiles, and fixes two bugs: - setpgid() confusion (see previous commit) - tcsetpgrp() now allows to set a non-empty process group even if the group leader has already died. This makes Serenity slightly more POSIX-compatible.
2020-08-08 20:04:20 +00:00
inline void Process::for_each_in_pgrp(ProcessGroupID pgid, Callback callback)
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
{
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
Process::all_instances().with([&](auto const& list) {
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
for (auto it = list.begin(); it != list.end();) {
auto& process = *it;
++it;
if (!process.is_dead() && process.pgid() == pgid) {
if (callback(process) == IterationDecision::Break)
break;
}
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
}
Kernel: Migrate process list locking to ProtectedValue The existing recursive spinlock is repurposed for profiling only, as it was shared with the process list.
2021-07-24 16:43:29 +00:00
});
Make Process::for_each...() functions inline and allocation-free. AK::Function is very handy, but costs us an 8-byte allocation. Let's not have kmalloc() calls in the scheduler hot path.
2018-11-08 15:09:05 +00:00
}
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<VoidFunction<Process&> Callback>
inline void Process::for_each(Callback callback)
{
return for_each([&](auto& item) {
callback(item);
return IterationDecision::Continue;
});
}
template<VoidFunction<Process&> Callback>
inline void Process::for_each_child(Callback callback)
{
return for_each_child([&](auto& item) {
callback(item);
return IterationDecision::Continue;
});
}
template<VoidFunction<Thread&> Callback>
inline IterationDecision Process::for_each_thread(Callback callback) const
{
Kernel: Port process thread lists to SpinLockProtectedValue I had to move the thread list out of the protected base area of Process so that it could live with its lock (which needs to be mutable). Ideally it would live in the protected area, so maybe we can figure out a way to do that later.
2021-08-07 11:28:18 +00:00
thread_list().with([&](auto& thread_list) {
for (auto& thread : thread_list)
callback(thread);
});
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
return IterationDecision::Continue;
}
Kernel: Add Process::try_for_each_thread() for fallible iteration This API will allow users to short circuit iteration and properly propagate errors.
2022-02-24 18:01:33 +00:00
inline ErrorOr<void> Process::try_for_each_thread(Function<ErrorOr<void>(Thread const&)> callback) const
{
return thread_list().with([&](auto& thread_list) -> ErrorOr<void> {
for (auto& thread : thread_list)
TRY(callback(thread));
return {};
});
}
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
template<VoidFunction<Thread&> Callback>
inline IterationDecision Process::for_each_thread(Callback callback)
{
Kernel: Port process thread lists to SpinLockProtectedValue I had to move the thread list out of the protected base area of Process so that it could live with its lock (which needs to be mutable). Ideally it would live in the protected area, so maybe we can figure out a way to do that later.
2021-08-07 11:28:18 +00:00
thread_list().with([&](auto& thread_list) {
for (auto& thread : thread_list)
callback(thread);
});
AK+Kernel+LibELF: Remove the need for `IteratorDecision::Continue` By constraining two implementations, the compiler will select the best fitting one. All this will require is duplicating the implementation and simplifying for the `void` case. This constraining also informs both the caller and compiler by passing the callback parameter types as part of the constraint (e.g.: `IterationFunction<int>`). Some `for_each` functions in LibELF only take functions which return `void`. This is a minimal correctness check, as it removes one way for a function to incompletely do something. There seems to be a possible idiom where inside a lambda, a `return;` is the same as `continue;` in a for-loop.
2021-05-16 09:36:52 +00:00
return IterationDecision::Continue;
}
template<VoidFunction<Process&> Callback>
inline void Process::for_each_in_pgrp(ProcessGroupID pgid, Callback callback)
{
return for_each_in_pgrp(pgid, [&](auto& item) {
callback(item);
return IterationDecision::Continue;
});
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
inline bool InodeMetadata::may_read(Process const& process) const
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
{
Kernel: Don't include the process GID in the "extra GIDs" table Process::m_extra_gids is for supplementary GIDs only.
2020-01-02 22:45:52 +00:00
return may_read(process.euid(), process.egid(), process.extra_gids());
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
inline bool InodeMetadata::may_write(Process const& process) const
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
{
Kernel: Don't include the process GID in the "extra GIDs" table Process::m_extra_gids is for supplementary GIDs only.
2020-01-02 22:45:52 +00:00
return may_write(process.euid(), process.egid(), process.extra_gids());
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
inline bool InodeMetadata::may_execute(Process const& process) const
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
{
Kernel: Don't include the process GID in the "extra GIDs" table Process::m_extra_gids is for supplementary GIDs only.
2020-01-02 22:45:52 +00:00
return may_execute(process.euid(), process.egid(), process.extra_gids());
Kernel: Start adding various file system permission checks. Fail with EACCES in various situations. Fix userland bugs that were exposed.
2019-02-21 14:45:31 +00:00
}
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
Kernel: PID/TID typing This compiles, and contains exactly the same bugs as before. The regex 'FIXME: PID/' should reveal all markers that I left behind, including: - Incomplete conversion - Issues or things that look fishy - Actual bugs that will go wrong during runtime
2020-08-08 15:32:34 +00:00
inline ProcessID Thread::pid() const
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
{
Kernel: Remove ProcessInspectionHandle and make Process RefCounted By making the Process class RefCounted we don't really need ProcessInspectionHandle anymore. This also fixes some race conditions where a Process may be deleted while still being used by ProcFS. Also make sure to acquire the Process' lock when accessing regions. Last but not least, there's no reason why a thread can't be scheduled while being inspected, though in practice it won't happen anyway because the scheduler lock is held at the same time.
2020-08-02 02:04:56 +00:00
return m_process->pid();
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
}
Kernel: Add LogStream operator<< for Process. It simply prints "process-name(pid)", nothing fancy, but kinda useful.
2019-07-08 16:58:19 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Kernel: Make copy_to/from_user safe and remove unnecessary checks Since the CPU already does almost all necessary validation steps for us, we don't really need to attempt to do this. Doing it ourselves doesn't really work very reliably, because we'd have to account for other processors modifying virtual memory, and we'd have to account for e.g. pages not being able to be allocated due to insufficient resources. So change the copy_to/from_user (and associated helper functions) to use the new safe_memcpy, which will return whether it succeeded or not. The only manual validation step needed (which the CPU can't perform for us) is making sure the pointers provided by user mode aren't pointing to kernel mappings. To make it easier to read/write from/to either kernel or user mode data add the UserOrKernelBuffer helper class, which will internally either use copy_from/to_user or directly memcpy, or pass the data through directly using a temporary buffer on the stack. Last but not least we need to keep syscall params trivial as we need to copy them from/to user mode using copy_from/to_user.
2020-09-12 03:11:07 +00:00
Kernel: Instrument syscalls with their process big lock requirements Currently all syscalls run under the Process:m_big_lock, which is an obvious bottleneck. Long term we would like to remove the big lock and replace it with the required fine grained locking. To facilitate this goal we need a way of gradually decomposing the big lock into the all of the required fine grained locks. This commit introduces instrumentation to the syscall table, allowing the big lock requirement to be toggled on/off per syscall. Eventually when we are finished, no syscall will required the big lock, and we'll be able to remove all of this instrumentation.
2021-07-18 16:18:35 +00:00
#define VERIFY_PROCESS_BIG_LOCK_ACQUIRED(process) \
Kernel: Require semicolon after VERIFY_{NO_,}PROCESS_BIG_LOCK_ACQUIRED This matches out general macro use, and specifically other verification macros like VERIFY(), VERIFY_NOT_REACHED(), VERIFY_INTERRUPTS_ENABLED(), and VERIFY_INTERRUPTS_DISABLED().
2022-08-17 20:03:04 +00:00
VERIFY(process->big_lock().is_exclusively_locked_by_current_thread())
Kernel: Instrument syscalls with their process big lock requirements Currently all syscalls run under the Process:m_big_lock, which is an obvious bottleneck. Long term we would like to remove the big lock and replace it with the required fine grained locking. To facilitate this goal we need a way of gradually decomposing the big lock into the all of the required fine grained locks. This commit introduces instrumentation to the syscall table, allowing the big lock requirement to be toggled on/off per syscall. Eventually when we are finished, no syscall will required the big lock, and we'll be able to remove all of this instrumentation.
2021-07-18 16:18:35 +00:00
#define VERIFY_NO_PROCESS_BIG_LOCK(process) \
Kernel: Require semicolon after VERIFY_{NO_,}PROCESS_BIG_LOCK_ACQUIRED This matches out general macro use, and specifically other verification macros like VERIFY(), VERIFY_NOT_REACHED(), VERIFY_INTERRUPTS_ENABLED(), and VERIFY_INTERRUPTS_DISABLED().
2022-08-17 20:03:04 +00:00
VERIFY(!process->big_lock().is_exclusively_locked_by_current_thread())
Kernel: Instrument syscalls with their process big lock requirements Currently all syscalls run under the Process:m_big_lock, which is an obvious bottleneck. Long term we would like to remove the big lock and replace it with the required fine grained locking. To facilitate this goal we need a way of gradually decomposing the big lock into the all of the required fine grained locks. This commit introduces instrumentation to the syscall table, allowing the big lock requirement to be toggled on/off per syscall. Eventually when we are finished, no syscall will required the big lock, and we'll be able to remove all of this instrumentation.
2021-07-18 16:18:35 +00:00
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
inline static ErrorOr<NonnullOwnPtr<KString>> try_copy_kstring_from_user(Kernel::Syscall::StringArgument const& string)
Kernel: Add try_copy_kstring_from_user() This is a convenience function that works the same as our old copy_string_from_user(), but this returns a KString (and can fail!)
2021-05-28 07:29:16 +00:00
{
Kernel: Remove char* versions of path argument / kstring copy methods The only two paths for copying strings in the kernel should be going through the existing Userspace<char const*>, or StringArgument methods. Lets enforce this by removing the option for using the raw cstring APIs that were previously available.
2021-08-13 05:04:31 +00:00
Userspace<char const*> characters((FlatPtr)string.characters);
return try_copy_kstring_from_user(characters, string.length);
Kernel: Add try_copy_kstring_from_user() This is a convenience function that works the same as our old copy_string_from_user(), but this returns a KString (and can fail!)
2021-05-28 07:29:16 +00:00
}
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:11:15 +00:00
template<>
Kernel: Convert Formatter<Process> to use Formatter<FormatString> This lets us avoid allocating memory on the heap most of the time, as Formatter<FormatString> writes into a quite large stack buffer instead.
2021-10-21 17:26:36 +00:00
struct AK::Formatter<Kernel::Process> : AK::Formatter<FormatString> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, Kernel::Process const& value)
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:11:15 +00:00
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
return AK::Formatter<FormatString>::format(builder, "{}({})"sv, value.name(), value.pid().value());
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:11:15 +00:00
}
};
Kernel: Clean up sys$futex and add support for cross-process futexes
2022-07-13 22:25:35 +00:00
namespace AK {
template<>
struct Traits<Kernel::GlobalFutexKey> : public GenericTraits<Kernel::GlobalFutexKey> {
static unsigned hash(Kernel::GlobalFutexKey const& futex_key) { return pair_int_hash(ptr_hash(futex_key.raw.parent), ptr_hash(futex_key.raw.offset)); }
static bool equals(Kernel::GlobalFutexKey const& a, Kernel::GlobalFutexKey const& b) { return a.raw.parent == b.raw.parent && a.raw.offset == b.raw.offset; }
};
};
Reference in a new issue Copy permalink