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

3975 lines
120 KiB
C++
Raw Normal View History

Kernel: Add realpath syscall
2019-08-25 16:17:05 +00:00
#include <AK/FileSystemPath.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <AK/StdLibExtras.h>
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#include <AK/StringBuilder.h>
Kernel: Fix timeout support in select The scheduler expects m_select_timeout to act as a deadline. That is, it should contain the time that a task should wake at -- but we were directly copying the time from userspace, which meant that it always returned virtually immediately. At the same time, fix CEventLoop to not rely on the broken select behavior by subtracting the current time from the time of the nearest timer.
2019-05-18 00:00:01 +00:00
#include <AK/Time.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <AK/Types.h>
Kernel: Move i386.{cpp,h} => Arch/i386/CPU.{cpp,h} There's a ton of work that would need to be done before we could spin up on another architecture, but let's at least try to separate things out a bit.
2019-06-07 18:02:01 +00:00
#include <Kernel/Arch/i386/CPU.h>
Kernel: Move i8253.cpp => Arch/i386/PIT.cpp
2019-07-09 12:23:12 +00:00
#include <Kernel/Arch/i386/PIT.h>
Kernel: Use a lookup table for syscalls Instead of the big ugly switch statement, build a lookup table using the syscall enumeration macro. This greatly simplifies the syscall implementation. :^)
2019-11-09 21:18:16 +00:00
#include <Kernel/Console.h>
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
#include <Kernel/Devices/KeyboardDevice.h>
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
#include <Kernel/Devices/NullDevice.h>
Kernel: Move PC speaker beep timing logic from scheduler to the syscall I don't know why I put this in the scheduler to begin with.. the caller can just block until the beeping is finished.
2019-12-26 21:31:26 +00:00
#include <Kernel/Devices/PCSpeaker.h>
Kernel: Add a Linux-style getrandom syscall The way it gets the entropy and blasts it to the buffer is pretty ugly IMHO, but it does work for now. (It should be replaced, by not truncating a u32.) It implements an (unused for now) flags argument, like Linux but instead of OpenBSD's. This is in case we want to distinguish between entropy sources or any other reason and have to implement a new syscall later. Of course, learn from Linux's struggles with entropy sourcing too.
2019-10-13 14:41:55 +00:00
#include <Kernel/Devices/RandomDevice.h>
FileSystem: Port most of the code over to using custodies. The current working directory is now stored as a custody. Likewise for a process executable file. This unbreaks /proc/PID/fd which has not been working since we made the filesystem bigger. This still needs a bunch of work, for instance when renaming or removing a file somewhere, we have to update the relevant custody links.
2019-05-30 16:58:59 +00:00
#include <Kernel/FileSystem/Custody.h>
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
#include <Kernel/FileSystem/DevPtsFS.h>
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
#include <Kernel/FileSystem/Ext2FileSystem.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/FileSystem/FIFO.h>
#include <Kernel/FileSystem/FileDescription.h>
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
#include <Kernel/FileSystem/InodeWatcher.h>
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
#include <Kernel/FileSystem/ProcFS.h>
#include <Kernel/FileSystem/TmpFS.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/FileSystem/VirtualFileSystem.h>
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
#include <Kernel/Heap/kmalloc.h>
Kernel+Userland: Addd reboot syscall (#334) Rolling with the theme of adding a dialog to shutdown the machine, it is probably nice to have a way to reboot the machine without performing a full system powerdown. A reboot program has been added to `/bin/` as well as a corresponding `syscall` (SC_reboot). This syscall works by attempting to pulse the 8042 keyboard controller. Note that this is NOT supported on new machines, and should only be a fallback until we have proper ACPI support. The implementation causes a triple fault in QEMU, which then restarts the system. The filesystems are locked and synchronized before this occurs, so there shouldn't be any corruption etctera.
2019-07-19 07:58:12 +00:00
#include <Kernel/IO.h>
Kernel: Use KBufferBuilder to build ProcFS files and backtraces This is not perfect as it uses a lot of VM, but since the buffers are supposed to be temporary it's not super terrible. This could be improved by giving back the unused VM to the kernel's RangeAllocator after finishing the buffer building.
2019-08-07 19:52:43 +00:00
#include <Kernel/KBufferBuilder.h>
Kernel: Qualify a bunch of #include statements.
2019-06-07 17:29:34 +00:00
#include <Kernel/KSyms.h>
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
#include <Kernel/KernelInfoPage.h>
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
#include <Kernel/Module.h>
Kernel: Make better use of the multiboot info. Define the multiboot info struct properly so we don't have to grab at byte offsets in the memory access checker code. Also print kernel command line in init().
2019-06-02 07:50:18 +00:00
#include <Kernel/Multiboot.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/Net/Socket.h>
Kernel: Qualify a bunch of #include statements.
2019-06-07 17:29:34 +00:00
#include <Kernel/Process.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/ProcessTracer.h>
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
#include <Kernel/Profiling.h>
Kernel: Qualify a bunch of #include statements.
2019-06-07 17:29:34 +00:00
#include <Kernel/RTC.h>
Kernel: Add a more expressive API for getting random bytes We now have these API's in <Kernel/Random.h>: - get_fast_random_bytes(u8* buffer, size_t buffer_size) - get_good_random_bytes(u8* buffer, size_t buffer_size) - get_fast_random<T>() - get_good_random<T>() Internally they both use x86 RDRAND if available, otherwise they fall back to the same LCG we had in RandomDevice all along. The main purpose of this patch is to give kernel code a way to better express its needs for random data. Randomness is something that will require a lot more work, but this is hopefully a step in the right direction.
2020-01-03 11:36:30 +00:00
#include <Kernel/Random.h>
Kernel: Qualify a bunch of #include statements.
2019-06-07 17:29:34 +00:00
#include <Kernel/Scheduler.h>
SharedBuffer: Fix deadlock on destroy We were locking the list of references, and then destroying the reference, which made things go a little crazy. It's more straightforward to just remove the per-reference lock: the syscalls all have to lock the full list anyway, so let's just do that and avoid the hassle. While I'm at it, also move the SharedBuffer code out to its own file as it's getting a little long and unwieldly, and Process.cpp is already huge.
2019-07-16 13:03:39 +00:00
#include <Kernel/SharedBuffer.h>
Kernel+Userland: Addd reboot syscall (#334) Rolling with the theme of adding a dialog to shutdown the machine, it is probably nice to have a way to reboot the machine without performing a full system powerdown. A reboot program has been added to `/bin/` as well as a corresponding `syscall` (SC_reboot). This syscall works by attempting to pulse the 8042 keyboard controller. Note that this is NOT supported on new machines, and should only be a fallback until we have proper ACPI support. The implementation causes a triple fault in QEMU, which then restarts the system. The filesystems are locked and synchronized before this occurs, so there shouldn't be any corruption etctera.
2019-07-19 07:58:12 +00:00
#include <Kernel/StdLib.h>
Kernel: Qualify a bunch of #include statements.
2019-06-07 17:29:34 +00:00
#include <Kernel/Syscall.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <Kernel/TTY/MasterPTY.h>
Kernel: Move E2BIG calculation from Thread to Process Thread::make_userspace_stack_for_main_thread is only ever called from Process::do_exec, after all the fun ELF loading and TSS setup has occured. The calculations in there that check if the combined argv + envp size will exceed the default stack size are not used in the rest of the stack setup. So, it should be safe to move this to the beginning of do_exec and bail early with -E2BIG, just like the man pages say. Additionally, advertise this limit in limits.h to be a good POSIX.1 citizen. :)
2019-10-20 16:11:40 +00:00
#include <Kernel/Thread.h>
Kernel: Split VMObject into two classes: Anonymous- and InodeVMObject InodeVMObject is a VMObject with an underlying Inode in the filesystem. AnonymousVMObject has no Inode. I'm happy that InodeVMObject::inode() can now return Inode& instead of VMObject::inode() return Inode*. :^)
2019-08-07 16:06:17 +00:00
#include <Kernel/VM/InodeVMObject.h>
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
#include <Kernel/VM/PurgeableVMObject.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <LibC/errno_numbers.h>
Kernel: writev() should fail with EINVAL if total length > INT32_MAX
2020-01-02 12:01:41 +00:00
#include <LibC/limits.h>
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
#include <LibC/signal_numbers.h>
LibELF: Move AK/ELF/ into Libraries/LibELF/ Let's arrange things like this instead. It didn't feel right for all of the ELF handling code to live in AK.
2019-11-06 12:42:38 +00:00
#include <LibELF/ELFLoader.h>
#include <LibELF/exec_elf.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: Add the ability to debug poll/select independently of read/write
2019-05-19 08:24:28 +00:00
//#define DEBUG_POLL_SELECT
Lots of hacking: - Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
2018-10-23 08:12:50 +00:00
//#define DEBUG_IO
Kernel: Put a bunch of debug spam behind #ifdefs.
2019-03-27 14:07:12 +00:00
//#define TASK_DEBUG
//#define FORK_DEBUG
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
//#define SIGNAL_DEBUG
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
//#define SHARED_BUFFER_DEBUG
Implement COW pages! :^) sys$fork() now clones all writable regions with per-page COW bits. The pages are then mapped read-only and we handle a PF by COWing the pages. This is quite delightful. Obviously there's lots of work to do still, and it needs better data structures, but the general concept works.
2018-11-05 12:48:07 +00:00
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
static void create_signal_trampolines();
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
static void create_kernel_info_page();
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +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 pid_t next_pid;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
InlineLinkedList<Process>* g_processes;
Add sys$gethostname and /bin/hostname
2018-10-26 07:54:29 +00:00
static String* s_hostname;
Kernel: Don't disable interrupts to access the system hostname.
2019-02-07 09:29:26 +00:00
static Lock* s_hostname_lock;
Kernel: Make sure the kernel info page is read-only for userspace To enforce this, we create two separate mappings of the same underlying physical page. A writable mapping for the kernel, and a read-only one for userspace (the one returned by sys$get_kernel_info_page.)
2019-12-15 21:21:28 +00:00
static VirtualAddress s_info_page_address_for_userspace;
static VirtualAddress s_info_page_address_for_kernel;
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
VirtualAddress g_return_to_ring3_from_signal_trampoline;
VirtualAddress g_return_to_ring0_from_signal_trampoline;
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
HashMap<String, OwnPtr<Module>>* g_modules;
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +00:00
Kernel: Make TID's be unique PID's This is a little strange, but it's how I understand things should work. The first thread in a new process now has TID == PID. Additional threads subsequently spawned in that process all have unique TID's generated by the PID allocator. TIDs are now globally unique.
2019-12-22 10:51:24 +00:00
pid_t Process::allocate_pid()
{
InterruptDisabler disabler;
return next_pid++;
}
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
void Process::initialize()
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: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
g_modules = new HashMap<String, OwnPtr<Module>>;
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
next_pid = 0;
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
g_processes = new InlineLinkedList<Process>;
Tweak default hostname.
2018-11-16 23:23:39 +00:00
s_hostname = new String("courage");
Kernel: Don't disable interrupts to access the system hostname.
2019-02-07 09:29:26 +00:00
s_hostname_lock = new Lock;
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
create_signal_trampolines();
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
create_kernel_info_page();
}
void Process::update_info_page_timestamp(const timeval& tv)
{
Kernel: Make sure the kernel info page is read-only for userspace To enforce this, we create two separate mappings of the same underlying physical page. A writable mapping for the kernel, and a read-only one for userspace (the one returned by sys$get_kernel_info_page.)
2019-12-15 21:21:28 +00:00
auto* info_page = (KernelInfoPage*)s_info_page_address_for_kernel.as_ptr();
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
info_page->serial++;
const_cast<timeval&>(info_page->now) = tv;
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
}
Kernel: Rewrite ProcFS. Now the filesystem is generated on-the-fly instead of manually adding and removing inodes as processes spawn and die. The code is convoluted and bloated as I wrote it while sleepless. However, it's still vastly better than the old ProcFS, so I'm committing it. I also added /proc/PID/fd/N symlinks for each of a process's open fd's.
2019-02-03 11:33:11 +00:00
Vector<pid_t> Process::all_pids()
{
Vector<pid_t> pids;
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
InterruptDisabler disabler;
AK: SinglyLinkedList::size_slow() should return size_t
2019-12-09 16:48:58 +00:00
pids.ensure_capacity((int)g_processes->size_slow());
Kernel: Use some more InlineLinkedList range-for iteration
2019-08-08 12:40:13 +00:00
for (auto& process : *g_processes)
pids.append(process.pid());
Kernel: Rewrite ProcFS. Now the filesystem is generated on-the-fly instead of manually adding and removing inodes as processes spawn and die. The code is convoluted and bloated as I wrote it while sleepless. However, it's still vastly better than the old ProcFS, so I'm committing it. I also added /proc/PID/fd/N symlinks for each of a process's open fd's.
2019-02-03 11:33:11 +00:00
return pids;
}
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
Vector<Process*> Process::all_processes()
Generate a basic /proc/summary file with some info about all tasks.
2018-10-23 10:44:46 +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
Vector<Process*> processes;
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
InterruptDisabler disabler;
AK: SinglyLinkedList::size_slow() should return size_t
2019-12-09 16:48:58 +00:00
processes.ensure_capacity((int)g_processes->size_slow());
Kernel: Use some more InlineLinkedList range-for iteration
2019-08-08 12:40:13 +00:00
for (auto& process : *g_processes)
processes.append(&process);
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
return processes;
Generate a basic /proc/summary file with some info about all tasks.
2018-10-23 10:44:46 +00:00
}
Add chown() syscall and a simple /bin/chown program.
2019-02-27 11:32:53 +00:00
bool Process::in_group(gid_t gid) const
{
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 m_gid == gid || m_extra_gids.contains(gid);
Add chown() syscall and a simple /bin/chown program.
2019-02-27 11:32:53 +00:00
}
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
Range Process::allocate_range(VirtualAddress vaddr, size_t size)
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: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
vaddr.mask(PAGE_MASK);
Make GraphicsBitmaps be Region-backed when running in the kernel. This is a lot better than having them in kmalloc memory. I'm gonna need a way to keep track of which process owns which bitmap eventually, maybe through some sort of resource keying system. We'll see.
2019-01-12 23:27:25 +00:00
size = PAGE_ROUND_UP(size);
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
if (vaddr.is_null())
Kernel: Let PageDirectory own the associated RangeAllocator. Since we transition to a new PageDirectory on exec(), we need a matching RangeAllocator to go with the new directory. Instead of juggling this in Process and MemoryManager, simply attach the RangeAllocator to the PageDirectory instead. Fixes #61.
2019-05-20 02:46:29 +00:00
return page_directory().range_allocator().allocate_anywhere(size);
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
return page_directory().range_allocator().allocate_specific(vaddr, size);
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
}
Kernel: Implement a simple virtual address range allocator. This replaces the previous virtual address allocator which was basically just "m_next_address += size;" With this in place, virtual addresses can get reused, which cuts down on the number of page tables created. When we implement ASLR some day, we'll probably have to do page table deallocation, but for now page tables are only deallocated once the process dies.
2019-05-17 01:40:15 +00:00
Kernel: Make the Process allocate_region* API's understand "int prot". Instead of having to inspect 'prot' at every call site, make the Process API's take care of that so we can just pass it through.
2019-05-30 14:14:37 +00:00
static unsigned prot_to_region_access_flags(int prot)
{
unsigned access = 0;
if (prot & PROT_READ)
access |= Region::Access::Read;
if (prot & PROT_WRITE)
access |= Region::Access::Write;
if (prot & PROT_EXEC)
access |= Region::Access::Execute;
return access;
}
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
Region& Process::allocate_split_region(const Region& source_region, const Range& range, size_t offset_in_vmobject)
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
{
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
m_regions.append(Region::create_user_accessible(range, source_region.vmobject(), offset_in_vmobject, source_region.name(), source_region.access()));
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
return m_regions.last();
}
Kernel: Tweak some String&& => const String&. String&& is just not very practical. Also return const String& when the returned string is a member variable. The call site is free to make a copy if he wants, but otherwise we can avoid the retain count churn.
2019-06-07 18:58:12 +00:00
Region* Process::allocate_region(VirtualAddress vaddr, size_t size, const String& name, int prot, bool commit)
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
{
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
auto range = allocate_range(vaddr, size);
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
if (!range.is_valid())
return nullptr;
Kernel: Track user accessibility per Region. Region now has is_user_accessible(), which informs the memory manager how to map these pages. Previously, we were just passing a "bool user_allowed" to various functions and I'm not at all sure that any of that was correct. All the Region constructors are now hidden, and you must go through one of these helpers to construct a region: - Region::create_user_accessible(...) - Region::create_kernel_only(...) That ensures that we don't accidentally create a Region without specifying user accessibility. :^)
2019-07-19 14:09:34 +00:00
m_regions.append(Region::create_user_accessible(range, name, prot_to_region_access_flags(prot)));
Kernel: Regions should be mapped into a PageDirectory, not a Process This patch changes the parameter to Region::map() to be a PageDirectory since that matches how we think about the memory model: Regions are views onto VMObjects, and are mapped into PageDirectories. Each Process has a PageDirectory. The kernel also has a PageDirectory.
2019-11-03 19:48:35 +00:00
m_regions.last().map(page_directory());
Kernel: Refactor Region/PageDirectory ownership model. Make PageDirectory retainable and have each Region co-own the PageDirectory they're mapped into. When unmapped, Region has no associated PageDirectory. This allows Region to automatically unmap itself when destroyed.
2019-01-22 04:01:00 +00:00
if (commit)
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
m_regions.last().commit();
return &m_regions.last();
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: Track user accessibility per Region. Region now has is_user_accessible(), which informs the memory manager how to map these pages. Previously, we were just passing a "bool user_allowed" to various functions and I'm not at all sure that any of that was correct. All the Region constructors are now hidden, and you must go through one of these helpers to construct a region: - Region::create_user_accessible(...) - Region::create_kernel_only(...) That ensures that we don't accidentally create a Region without specifying user accessibility. :^)
2019-07-19 14:09:34 +00:00
Region* Process::allocate_file_backed_region(VirtualAddress vaddr, size_t size, NonnullRefPtr<Inode> inode, const String& name, int prot)
Support basic mmap'ing of a file! All right, we can now mmap() a file and it gets magically paged in from fs in response to an NP page fault. This is really cool :^) I need to refactor this to support sharing of read-only file-backed pages, but it's cool to just have something working.
2018-11-08 11:59:16 +00:00
{
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
auto range = allocate_range(vaddr, size);
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
if (!range.is_valid())
return nullptr;
Kernel: Track user accessibility per Region. Region now has is_user_accessible(), which informs the memory manager how to map these pages. Previously, we were just passing a "bool user_allowed" to various functions and I'm not at all sure that any of that was correct. All the Region constructors are now hidden, and you must go through one of these helpers to construct a region: - Region::create_user_accessible(...) - Region::create_kernel_only(...) That ensures that we don't accidentally create a Region without specifying user accessibility. :^)
2019-07-19 14:09:34 +00:00
m_regions.append(Region::create_user_accessible(range, inode, name, prot_to_region_access_flags(prot)));
Kernel: Regions should be mapped into a PageDirectory, not a Process This patch changes the parameter to Region::map() to be a PageDirectory since that matches how we think about the memory model: Regions are views onto VMObjects, and are mapped into PageDirectories. Each Process has a PageDirectory. The kernel also has a PageDirectory.
2019-11-03 19:48:35 +00:00
m_regions.last().map(page_directory());
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
return &m_regions.last();
Support basic mmap'ing of a file! All right, we can now mmap() a file and it gets magically paged in from fs in response to an NP page fault. This is really cool :^) I need to refactor this to support sharing of read-only file-backed pages, but it's cool to just have something working.
2018-11-08 11:59:16 +00:00
}
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
Region* Process::allocate_region_with_vmobject(VirtualAddress vaddr, size_t size, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, const String& name, int prot)
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
{
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
auto range = allocate_range(vaddr, size);
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
if (!range.is_valid())
return nullptr;
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
offset_in_vmobject &= PAGE_MASK;
m_regions.append(Region::create_user_accessible(range, move(vmobject), offset_in_vmobject, name, prot_to_region_access_flags(prot)));
Kernel: Regions should be mapped into a PageDirectory, not a Process This patch changes the parameter to Region::map() to be a PageDirectory since that matches how we think about the memory model: Regions are views onto VMObjects, and are mapped into PageDirectories. Each Process has a PageDirectory. The kernel also has a PageDirectory.
2019-11-03 19:48:35 +00:00
m_regions.last().map(page_directory());
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
return &m_regions.last();
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
}
Use ELF program headers to load executables smarter. This turned out way better than the old code. ELF loading is now quite straightforward, and we don't need the weird concept of subregions anymore. Next step is to respect the is_writable flag.
2018-11-03 10:28:23 +00:00
bool Process::deallocate_region(Region& region)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
{
Canonicalize the path used by sh. With a bunch of LibC work to support the feature. LibC now initializes AK::StringImpl by default. It's now fine to use AK in LibC/Userland! :^)
2018-10-28 08:36:21 +00:00
InterruptDisabler disabler;
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
for (int i = 0; i < m_regions.size(); ++i) {
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
if (&m_regions[i] == &region) {
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
m_regions.remove(i);
return true;
}
}
return false;
}
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
Region* Process::region_from_range(const Range& range)
{
size_t size = PAGE_ROUND_UP(range.size());
for (auto& region : m_regions) {
if (region.vaddr() == range.base() && region.size() == size)
return &region;
}
return nullptr;
}
Region* Process::region_containing(const Range& range)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
{
for (auto& region : m_regions) {
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
if (region.contains(range))
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
return &region;
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
}
return nullptr;
}
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
int Process::sys$set_mmap_name(void* addr, size_t size, const char* name)
Add sys$set_mmap_name and use it from LibC's malloc. It's nice to be able to identify mmap's in /proc/PID/vm.
2018-10-28 08:57:22 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(name))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
auto* region = region_from_range({ VirtualAddress((u32)addr), size });
Add sys$set_mmap_name and use it from LibC's malloc. It's nice to be able to identify mmap's in /proc/PID/vm.
2018-10-28 08:57:22 +00:00
if (!region)
return -EINVAL;
Kernel: Mark mmap()-created regions with a special bit Then only allow regions with that bit to be manipulated via munmap() and mprotect(). This prevents messing with non-mmap()ed regions in a process's address space (stacks, shared buffers, ...)
2019-11-24 11:24:16 +00:00
if (!region->is_mmap())
return -EPERM;
Kernel: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
region->set_name(String(name));
Add sys$set_mmap_name and use it from LibC's malloc. It's nice to be able to identify mmap's in /proc/PID/vm.
2018-10-28 08:57:22 +00:00
return 0;
}
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
static bool validate_mmap_prot(int prot, bool map_stack)
{
bool readable = prot & PROT_READ;
bool writable = prot & PROT_WRITE;
bool executable = prot & PROT_EXEC;
if (writable && executable)
return false;
if (map_stack) {
if (executable)
return false;
if (!readable || !writable)
return false;
}
return true;
}
Kernel: sys$mprotect protects sub-regions as well as whole ones Split a region into two/three if the desired mprotect range is a strict subset of an existing region. We can then set the access bits on a new region that is just our desired range and add both the new desired subregion and the leftovers back to our page tables.
2019-12-30 20:11:25 +00:00
// Carve out a virtual address range from a region and return the two regions on either side
Vector<Region*, 2> Process::split_region_around_range(const Region& source_region, const Range& desired_range)
{
Range old_region_range = source_region.range();
auto remaining_ranges_after_unmap = old_region_range.carve(desired_range);
ASSERT(!remaining_ranges_after_unmap.is_empty());
auto make_replacement_region = [&](const Range& new_range) -> Region& {
ASSERT(new_range.base() >= old_region_range.base());
ASSERT(new_range.end() <= old_region_range.end());
size_t new_range_offset_in_vmobject = source_region.offset_in_vmobject() + (new_range.base().get() - old_region_range.base().get());
return allocate_split_region(source_region, new_range, new_range_offset_in_vmobject);
};
Vector<Region*, 2> new_regions;
for (auto& new_range : remaining_ranges_after_unmap) {
new_regions.unchecked_append(&make_replacement_region(new_range));
}
return new_regions;
}
Start working on memory-mapped files. First of all, change sys$mmap to take a struct SC_mmap_params since our sycsall calling convention can't handle more than 3 arguments. This exposed a bug in Syscall::invoke() needing to use clobber lists. It was a bit confusing to debug. :^)
2018-11-08 10:37:01 +00:00
void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
{
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
if (!validate_read(params, sizeof(Syscall::SC_mmap_params)))
return (void*)-EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [addr, size, prot, flags, fd, offset, name] = *params;
if (name && !validate_read_str(name))
LibC: Add mmap_with_name() that names the allocation immediately. This allows us to skip the separate call to set_mmap_name() in code that we control, e.g malloc() and GraphicsBitmap.
2019-05-19 13:54:56 +00:00
return (void*)-EFAULT;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
Support basic mmap'ing of a file! All right, we can now mmap() a file and it gets magically paged in from fs in response to an NP page fault. This is really cool :^) I need to refactor this to support sharing of read-only file-backed pages, but it's cool to just have something working.
2018-11-08 11:59:16 +00:00
if (size == 0)
return (void*)-EINVAL;
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
if ((u32)addr & ~PAGE_MASK)
Support basic mmap'ing of a file! All right, we can now mmap() a file and it gets magically paged in from fs in response to an NP page fault. This is really cool :^) I need to refactor this to support sharing of read-only file-backed pages, but it's cool to just have something working.
2018-11-08 11:59:16 +00:00
return (void*)-EINVAL;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
bool map_shared = flags & MAP_SHARED;
bool map_anonymous = flags & MAP_ANONYMOUS;
bool map_purgeable = flags & MAP_PURGEABLE;
bool map_private = flags & MAP_PRIVATE;
bool map_stack = flags & MAP_STACK;
Kernel: Retry mmap if MAP_FIXED is not in flags and addr is not 0 If an mmap fails to allocate a region, but the addr passed in was non-zero, non-fixed mmaps should attempt to allocate at any available virtual address.
2019-12-29 05:54:10 +00:00
bool map_fixed = flags & MAP_FIXED;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (map_shared && map_private)
Kernel: mmap() with both MAP_PRIVATE and MAP_SHARED is an error
2019-10-01 17:31:55 +00:00
return (void*)-EINVAL;
Kernel: Implement some basic stack pointer validation VM regions can now be marked as stack regions, which is then validated on syscall, and on page fault. If a thread is caught with its stack pointer pointing into anything that's *not* a Region with its stack bit set, we'll crash the whole process with SIGSTKFLT. Userspace must now allocate custom stacks by using mmap() with the new MAP_STACK flag. This mechanism was first introduced in OpenBSD, and now we have it too, yay! :^)
2019-11-17 11:11:43 +00:00
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (!map_shared && !map_private)
Kernel: Don't allow mmap()/mprotect() to set up PROT_WRITE|PROT_EXEC ..but also allow mprotect() to set PROT_EXEC on a region, something we were just ignoring before.
2019-12-25 10:54:16 +00:00
return (void*)-EINVAL;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (!validate_mmap_prot(prot, map_stack))
Kernel: Implement some basic stack pointer validation VM regions can now be marked as stack regions, which is then validated on syscall, and on page fault. If a thread is caught with its stack pointer pointing into anything that's *not* a Region with its stack bit set, we'll crash the whole process with SIGSTKFLT. Userspace must now allocate custom stacks by using mmap() with the new MAP_STACK flag. This mechanism was first introduced in OpenBSD, and now we have it too, yay! :^)
2019-11-17 11:11:43 +00:00
return (void*)-EINVAL;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (map_stack && (!map_private || !map_anonymous))
Kernel: Implement some basic stack pointer validation VM regions can now be marked as stack regions, which is then validated on syscall, and on page fault. If a thread is caught with its stack pointer pointing into anything that's *not* a Region with its stack bit set, we'll crash the whole process with SIGSTKFLT. Userspace must now allocate custom stacks by using mmap() with the new MAP_STACK flag. This mechanism was first introduced in OpenBSD, and now we have it too, yay! :^)
2019-11-17 11:11:43 +00:00
return (void*)-EINVAL;
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
Region* region = nullptr;
if (map_purgeable) {
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
auto vmobject = PurgeableVMObject::create_with_size(size);
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
region = allocate_region_with_vmobject(VirtualAddress((u32)addr), size, vmobject, 0, name ? name : "mmap (purgeable)", prot);
Kernel: Retry mmap if MAP_FIXED is not in flags and addr is not 0 If an mmap fails to allocate a region, but the addr passed in was non-zero, non-fixed mmaps should attempt to allocate at any available virtual address.
2019-12-29 05:54:10 +00:00
if (!region && (!map_fixed && addr != 0))
region = allocate_region_with_vmobject({}, size, vmobject, 0, name ? name : "mmap (purgeable)", prot);
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
} else if (map_anonymous) {
region = allocate_region(VirtualAddress((u32)addr), size, name ? name : "mmap", prot, false);
Kernel: Retry mmap if MAP_FIXED is not in flags and addr is not 0 If an mmap fails to allocate a region, but the addr passed in was non-zero, non-fixed mmaps should attempt to allocate at any available virtual address.
2019-12-29 05:54:10 +00:00
if (!region && (!map_fixed && addr != 0))
region = allocate_region({}, size, name ? name : "mmap", prot, false);
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
} else {
if (offset < 0)
return (void*)-EINVAL;
if (static_cast<size_t>(offset) & ~PAGE_MASK)
return (void*)-EINVAL;
auto* description = file_description(fd);
if (!description)
return (void*)-EBADF;
auto region_or_error = description->mmap(*this, VirtualAddress((u32)addr), static_cast<size_t>(offset), size, prot);
Kernel: Retry mmap if MAP_FIXED is not in flags and addr is not 0 If an mmap fails to allocate a region, but the addr passed in was non-zero, non-fixed mmaps should attempt to allocate at any available virtual address.
2019-12-29 05:54:10 +00:00
if (region_or_error.is_error()) {
// Fail if MAP_FIXED or address is 0, retry otherwise
if (map_fixed || addr == 0)
return (void*)(int)region_or_error.error();
region_or_error = description->mmap(*this, {}, static_cast<size_t>(offset), size, prot);
}
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (region_or_error.is_error())
return (void*)(int)region_or_error.error();
region = region_or_error.value();
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
}
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (!region)
return (void*)-ENOMEM;
region->set_mmap(true);
if (map_shared)
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
region->set_shared(true);
Kernel: Clarify the various input validity checks in mmap() Also share some validation logic between mmap() and mprotect().
2019-12-25 20:50:13 +00:00
if (map_stack)
region->set_stack(true);
LibC: Add mmap_with_name() that names the allocation immediately. This allows us to skip the separate call to set_mmap_name() in code that we control, e.g malloc() and GraphicsBitmap.
2019-05-19 13:54:56 +00:00
if (name)
region->set_name(name);
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
return region->vaddr().as_ptr();
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +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
int Process::sys$munmap(void* addr, size_t size)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
{
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
Range range_to_unmap { VirtualAddress((u32)addr), size };
if (auto* whole_region = region_from_range(range_to_unmap)) {
Kernel: Mark mmap()-created regions with a special bit Then only allow regions with that bit to be manipulated via munmap() and mprotect(). This prevents messing with non-mmap()ed regions in a process's address space (stacks, shared buffers, ...)
2019-11-24 11:24:16 +00:00
if (!whole_region->is_mmap())
return -EPERM;
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
bool success = deallocate_region(*whole_region);
ASSERT(success);
return 0;
}
if (auto* old_region = region_containing(range_to_unmap)) {
Kernel: Mark mmap()-created regions with a special bit Then only allow regions with that bit to be manipulated via munmap() and mprotect(). This prevents messing with non-mmap()ed regions in a process's address space (stacks, shared buffers, ...)
2019-11-24 11:24:16 +00:00
if (!old_region->is_mmap())
return -EPERM;
Kernel: sys$mprotect protects sub-regions as well as whole ones Split a region into two/three if the desired mprotect range is a strict subset of an existing region. We can then set the access bits on a new region that is just our desired range and add both the new desired subregion and the leftovers back to our page tables.
2019-12-30 20:11:25 +00:00
auto new_regions = split_region_around_range(*old_region, range_to_unmap);
Kernel: Fix partial munmap() deallocating still-in-use VM We were always returning the full VM range of the partially-unmapped Region to the range allocator. This caused us to re-use those addresses for subsequent VM allocations. This patch also skips creating a new VMObject in partial munmap(). Instead we just make split regions that point into the same VMObject. This fixes the mysterious GCC ICE on large C++ programs.
2019-09-27 18:17:41 +00:00
// We manually unmap the old region here, specifying that we *don't* want the VM deallocated.
Kernel: Move region map/unmap operations into the Region class The more Region can take care of itself, the better.
2019-11-03 19:37:03 +00:00
old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
deallocate_region(*old_region);
Kernel: Fix partial munmap() deallocating still-in-use VM We were always returning the full VM range of the partially-unmapped Region to the range allocator. This caused us to re-use those addresses for subsequent VM allocations. This patch also skips creating a new VMObject in partial munmap(). Instead we just make split regions that point into the same VMObject. This fixes the mysterious GCC ICE on large C++ programs.
2019-09-27 18:17:41 +00:00
// Instead we give back the unwanted VM manually.
page_directory().range_allocator().deallocate(range_to_unmap);
Kernel: sys$mprotect protects sub-regions as well as whole ones Split a region into two/three if the desired mprotect range is a strict subset of an existing region. We can then set the access bits on a new region that is just our desired range and add both the new desired subregion and the leftovers back to our page tables.
2019-12-30 20:11:25 +00:00
// And finally we map the new region(s) using our page directory (they were just allocated and don't have one).
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
for (auto* new_region : new_regions) {
Kernel: Regions should be mapped into a PageDirectory, not a Process This patch changes the parameter to Region::map() to be a PageDirectory since that matches how we think about the memory model: Regions are views onto VMObjects, and are mapped into PageDirectories. Each Process has a PageDirectory. The kernel also has a PageDirectory.
2019-11-03 19:48:35 +00:00
new_region->map(page_directory());
Kernel: Support partial munmap() You can now munmap() a part of a region. The kernel will then create one or two new regions around the "hole" and re-map them using the same physical pages as before. This goes towards fixing #175, but not all the way since we don't yet do munmap() across multiple mappings.
2019-08-29 18:57:02 +00:00
}
return 0;
}
// FIXME: We should also support munmap() across multiple regions. (#175)
return -EINVAL;
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
}
Kernel+LibC+crash: Add mprotect() syscall This patch adds the mprotect() syscall to allow changing the protection flags for memory regions. We don't do any region splitting/merging yet, so this only works on whole mmap() regions. Added a "crash -r" flag to verify that we crash when you attempt to write to read-only memory. :^)
2019-08-12 17:33:24 +00:00
int Process::sys$mprotect(void* addr, size_t size, int prot)
{
Kernel: sys$mprotect protects sub-regions as well as whole ones Split a region into two/three if the desired mprotect range is a strict subset of an existing region. We can then set the access bits on a new region that is just our desired range and add both the new desired subregion and the leftovers back to our page tables.
2019-12-30 20:11:25 +00:00
Range range_to_mprotect = { VirtualAddress((u32)addr), size };
if (auto* whole_region = region_from_range(range_to_mprotect)) {
if (!whole_region->is_mmap())
return -EPERM;
if (!validate_mmap_prot(prot, whole_region->is_stack()))
return -EINVAL;
if (whole_region->access() == prot_to_region_access_flags(prot))
return 0;
whole_region->set_readable(prot & PROT_READ);
whole_region->set_writable(prot & PROT_WRITE);
whole_region->set_executable(prot & PROT_EXEC);
whole_region->remap();
return 0;
}
// Check if we can carve out the desired range from an existing region
if (auto* old_region = region_containing(range_to_mprotect)) {
if (!old_region->is_mmap())
return -EPERM;
if (!validate_mmap_prot(prot, old_region->is_stack()))
return -EINVAL;
if (old_region->access() == prot_to_region_access_flags(prot))
return 0;
// This vector is the region(s) adjacent to our range.
// We need to allocate a new region for the range we wanted to change permission bits on.
auto adjacent_regions = split_region_around_range(*old_region, range_to_mprotect);
size_t new_range_offset_in_vmobject = old_region->offset_in_vmobject() + (range_to_mprotect.base().get() - old_region->range().base().get());
auto& new_region = allocate_split_region(*old_region, range_to_mprotect, new_range_offset_in_vmobject);
new_region.set_readable(prot & PROT_READ);
new_region.set_writable(prot & PROT_WRITE);
new_region.set_executable(prot & PROT_EXEC);
// Unmap the old region here, specifying that we *don't* want the VM deallocated.
old_region->unmap(Region::ShouldDeallocateVirtualMemoryRange::No);
deallocate_region(*old_region);
// Map the new regions using our page directory (they were just allocated and don't have one).
for (auto* adjacent_region : adjacent_regions) {
adjacent_region->map(page_directory());
}
new_region.map(page_directory());
return 0;
}
// FIXME: We should also support mprotect() across multiple regions. (#175) (#964)
return -EINVAL;
Kernel+LibC+crash: Add mprotect() syscall This patch adds the mprotect() syscall to allow changing the protection flags for memory regions. We don't do any region splitting/merging yet, so this only works on whole mmap() regions. Added a "crash -r" flag to verify that we crash when you attempt to write to read-only memory. :^)
2019-08-12 17:33:24 +00:00
}
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
int Process::sys$madvise(void* address, size_t size, int advice)
{
auto* region = region_from_range({ VirtualAddress((u32)address), size });
if (!region)
return -EINVAL;
if (!region->is_mmap())
return -EPERM;
if ((advice & MADV_SET_VOLATILE) && (advice & MADV_SET_NONVOLATILE))
return -EINVAL;
if (advice & MADV_SET_VOLATILE) {
if (!region->vmobject().is_purgeable())
return -EPERM;
auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
vmobject.set_volatile(true);
return 0;
}
if (advice & MADV_SET_NONVOLATILE) {
if (!region->vmobject().is_purgeable())
return -EPERM;
auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
Kernel: Ignore MADV_SET_NONVOLATILE if already non-volatile Just return 0 right away without changing any region flags.
2019-12-18 19:48:58 +00:00
if (!vmobject.is_volatile())
return 0;
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
vmobject.set_volatile(false);
bool was_purged = vmobject.was_purged();
vmobject.set_was_purged(false);
return was_purged ? 1 : 0;
}
Kernel: Add MADV_GET_VOLATILE for checking the volatile flag Sometimes you might want to know if a purgeable region is volatile.
2019-12-18 19:48:24 +00:00
if (advice & MADV_GET_VOLATILE) {
if (!region->vmobject().is_purgeable())
return -EPERM;
auto& vmobject = static_cast<PurgeableVMObject&>(region->vmobject());
return vmobject.is_volatile() ? 0 : 1;
}
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
return -EINVAL;
}
Kernel: Add a mode flag to sys$purge and allow purging clean inodes
2019-12-29 12:16:53 +00:00
int Process::sys$purge(int mode)
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
{
Kernel: Make the purge() syscall superuser-only I don't think we need to give unprivileged users access to what is essentially a kernel testing mechanism.
2020-01-02 12:37:23 +00:00
if (!is_superuser())
return -EPERM;
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
int purged_page_count = 0;
Kernel: Add a mode flag to sys$purge and allow purging clean inodes
2019-12-29 12:16:53 +00:00
if (mode & PURGE_ALL_VOLATILE) {
NonnullRefPtrVector<PurgeableVMObject> vmobjects;
{
InterruptDisabler disabler;
MM.for_each_vmobject([&](auto& vmobject) {
if (vmobject.is_purgeable())
vmobjects.append(static_cast<PurgeableVMObject&>(vmobject));
return IterationDecision::Continue;
});
}
for (auto& vmobject : vmobjects) {
purged_page_count += vmobject.purge();
}
}
if (mode & PURGE_ALL_CLEAN_INODE) {
NonnullRefPtrVector<InodeVMObject> vmobjects;
{
InterruptDisabler disabler;
MM.for_each_vmobject([&](auto& vmobject) {
if (vmobject.is_inode())
vmobjects.append(static_cast<InodeVMObject&>(vmobject));
return IterationDecision::Continue;
});
}
for (auto& vmobject : vmobjects) {
purged_page_count += vmobject.release_all_clean_pages();
}
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
}
return purged_page_count;
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
int Process::sys$gethostname(char* buffer, ssize_t size)
Add sys$gethostname and /bin/hostname
2018-10-26 07:54:29 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
if (!validate_write(buffer, size))
return -EFAULT;
Kernel: Don't disable interrupts to access the system hostname.
2019-02-07 09:29:26 +00:00
LOCKER(*s_hostname_lock);
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if ((size_t)size < (s_hostname->length() + 1))
Add sys$gethostname and /bin/hostname
2018-10-26 07:54:29 +00:00
return -ENAMETOOLONG;
Kernel: Don't disable interrupts to access the system hostname.
2019-02-07 09:29:26 +00:00
strcpy(buffer, s_hostname->characters());
Implement argc/argv support for spawned tasks. Celebrate the new functionality with a simple /bin/cat implementation. :^)
2018-10-26 09:16:56 +00:00
return 0;
Add sys$gethostname and /bin/hostname
2018-10-26 07:54:29 +00:00
}
Kernel: Merge Process::fork() into sys$fork() There was no good reason for this to be a separate function.
2019-12-19 18:07:41 +00:00
pid_t Process::sys$fork(RegisterDump& regs)
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: 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
Thread* child_first_thread = nullptr;
auto* child = new Process(child_first_thread, m_name, m_uid, m_gid, m_pid, m_ring, m_cwd, m_executable, m_tty, this);
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
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
#ifdef FORK_DEBUG
dbgprintf("fork: child=%p\n", child);
#endif
for (auto& region : m_regions) {
#ifdef FORK_DEBUG
Kernel: Fix bitrotted FORK_DEBUG logging code
2019-09-27 11:57:35 +00:00
dbg() << "fork: cloning Region{" << &region << "} '" << region.name() << "' @ " << region.vaddr();
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
#endif
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
child->m_regions.append(region.clone());
Kernel: Regions should be mapped into a PageDirectory, not a Process This patch changes the parameter to Region::map() to be a PageDirectory since that matches how we think about the memory model: Regions are views onto VMObjects, and are mapped into PageDirectories. Each Process has a PageDirectory. The kernel also has a PageDirectory.
2019-11-03 19:48:35 +00:00
child->m_regions.last().map(child->page_directory());
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
if (&region == m_master_tls_region)
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
child->m_master_tls_region = &child->m_regions.last();
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: 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
child->m_extra_gids = m_extra_gids;
Kernel: Clone Process::m_gids on fork() and hook up any framebuffer region.
2019-01-21 00:49:30 +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
auto& child_tss = child_first_thread->m_tss;
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
child_tss.eax = 0; // fork() returns 0 in the child :^)
child_tss.ebx = regs.ebx;
child_tss.ecx = regs.ecx;
child_tss.edx = regs.edx;
child_tss.ebp = regs.ebp;
child_tss.esp = regs.esp_if_crossRing;
child_tss.esi = regs.esi;
child_tss.edi = regs.edi;
child_tss.eflags = regs.eflags;
child_tss.eip = regs.eip;
child_tss.cs = regs.cs;
child_tss.ds = regs.ds;
child_tss.es = regs.es;
child_tss.fs = regs.fs;
child_tss.gs = regs.gs;
child_tss.ss = regs.ss_if_crossRing;
Kernel: Implement lazy FPU state restore.
2019-01-25 06:52:44 +00:00
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
#ifdef FORK_DEBUG
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
dbgprintf("fork: child will begin executing at %w:%x with stack %w:%x, kstack %w:%x\n", child_tss.cs, child_tss.eip, child_tss.ss, child_tss.esp, child_tss.ss0, child_tss.esp0);
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
#endif
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
{
InterruptDisabler disabler;
g_processes->prepend(child);
}
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
#ifdef TASK_DEBUG
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
kprintf("Process %u (%s) forked from %u @ %p\n", child->pid(), child->name().characters(), m_pid, child_tss.eip);
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
#endif
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: 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
child_first_thread->set_state(Thread::State::Skip1SchedulerPass);
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
return child->pid();
}
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
int Process::do_exec(String path, Vector<String> arguments, Vector<String> environment)
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
{
Kernel: Increase default userspace stack size to 64 kilobytes.
2019-02-03 02:56:08 +00:00
ASSERT(is_ring3());
Kernel: Make it possible to look up FIFO's by ID. This will be useful when implementing the /proc/PID/fd/N links where N is a file descriptor referring to a FIFO.
2019-04-25 11:52:07 +00:00
dbgprintf("%s(%d) do_exec(%s): thread_count() = %d\n", m_name.characters(), m_pid, path.characters(), thread_count());
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
// FIXME(Thread): Kill any threads the moment we commit to the exec().
Kernel: Process destruction should destroy all child threads. We were only destroying the main thread when a process died, leaving any secondary threads around. They couldn't run, but because they were still in the global thread list, strange things could happen since they had some now-stale pointers to their old process.
2019-04-23 20:17:01 +00:00
if (thread_count() != 1) {
dbgprintf("Gonna die because I have many threads! These are the threads:\n");
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
for_each_thread([](Thread& thread) {
Kernel: Process destruction should destroy all child threads. We were only destroying the main thread when a process died, leaving any secondary threads around. They couldn't run, but because they were still in the global thread list, strange things could happen since they had some now-stale pointers to their old process.
2019-04-23 20:17:01 +00:00
dbgprintf("Thread{%p}: TID=%d, PID=%d\n", &thread, thread.tid(), thread.pid());
return IterationDecision::Continue;
});
ASSERT(thread_count() == 1);
ASSERT_NOT_REACHED();
}
Kernel: Move E2BIG calculation from Thread to Process Thread::make_userspace_stack_for_main_thread is only ever called from Process::do_exec, after all the fun ELF loading and TSS setup has occured. The calculations in there that check if the combined argv + envp size will exceed the default stack size are not used in the rest of the stack setup. So, it should be safe to move this to the beginning of do_exec and bail early with -E2BIG, just like the man pages say. Additionally, advertise this limit in limits.h to be a good POSIX.1 citizen. :)
2019-10-20 16:11:40 +00:00
size_t total_blob_size = 0;
for (auto& a : arguments)
total_blob_size += a.length() + 1;
for (auto& e : environment)
total_blob_size += e.length() + 1;
size_t total_meta_size = sizeof(char*) * (arguments.size() + 1) + sizeof(char*) * (environment.size() + 1);
// FIXME: How much stack space does process startup need?
if ((total_blob_size + total_meta_size) >= Thread::default_userspace_stack_size)
return -E2BIG;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
auto parts = path.split('/');
Yet another pass of style fixes.
2018-12-21 01:10:45 +00:00
if (parts.is_empty())
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
return -ENOENT;
AK: Add implicit String -> StringView conversion And tidy up existing view() users.
2019-06-02 10:19:21 +00:00
auto result = VFS::the().open(path, 0, 0, current_directory());
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
if (result.is_error())
return result.error();
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto description = result.value();
auto metadata = description->metadata();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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
if (!metadata.may_execute(*this))
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
return -EACCES;
Kernel: Do a bit more of do_exec() before disabling interrupts. We definitely need to replace m_executable before clearing interrupts, since otherwise we might call ~Custody() which would make it assert in locking. Also avoid calling FileDescriptor::metadata() repeatedly and just cache the result from the first call. I also added a comment at the point where we've decided to commit to the new executable and follow through with the swap.
2019-05-31 05:02:43 +00:00
if (!metadata.size)
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
return -ENOTIMPL;
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 entry_eip = 0;
Let PageDirectory have a PhysicalPage for the PDB instead of being the PDB. This is more efficient than using the wasteful kmalloc_aligned() approach to allocation. It also allows much tighter encapsulation of the class.
2018-12-31 13:58:03 +00:00
// FIXME: Is there a race here?
auto old_page_directory = move(m_page_directory);
Kernel: Add mapping from page directory base (PDB) to PageDirectory This allows the page fault code to find the owning PageDirectory and corresponding process for faulting regions. The mapping is implemented as a global hash map right now, which is definitely not optimal. We can come up with something better when it becomes necessary.
2019-08-06 09:19:16 +00:00
m_page_directory = PageDirectory::create_for_userspace(*this);
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
#ifdef MM_DEBUG
Let PageDirectory have a PhysicalPage for the PDB instead of being the PDB. This is more efficient than using the wasteful kmalloc_aligned() approach to allocation. It also allows much tighter encapsulation of the class.
2018-12-31 13:58:03 +00:00
dbgprintf("Process %u exec: PD=%x created\n", pid(), m_page_directory.ptr());
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
#endif
ProcessPagingScope paging_scope(*this);
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
Kernel: Split VMObject into two classes: Anonymous- and InodeVMObject InodeVMObject is a VMObject with an underlying Inode in the filesystem. AnonymousVMObject has no Inode. I'm happy that InodeVMObject::inode() can now return Inode& instead of VMObject::inode() return Inode*. :^)
2019-08-07 16:06:17 +00:00
ASSERT(description->inode());
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
auto vmobject = InodeVMObject::create_with_inode(*description->inode());
auto* region = allocate_region_with_vmobject(VirtualAddress(), metadata.size, vmobject, 0, description->absolute_path(), PROT_READ);
Kernel: Factor out range allocation from Process::allocate_region*(). These functions were doing exactly the same thing for range allocation, so share that code in an allocate_range() helper. Region allocation will now also fail if range allocation fails, which means that mmap() can actually fail without falling apart. Exciting times!
2019-05-17 02:39:22 +00:00
ASSERT(region);
Kernel: Refactor Region/PageDirectory ownership model. Make PageDirectory retainable and have each Region co-own the PageDirectory they're mapped into. When unmapped, Region has no associated PageDirectory. This allows Region to automatically unmap itself when destroyed.
2019-01-22 04:01:00 +00:00
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
// NOTE: We yank this out of 'm_regions' since we're about to manipulate the vector
// and we don't want it getting lost.
auto executable_region = m_regions.take_last();
Region* master_tls_region { nullptr };
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 master_tls_size = 0;
size_t master_tls_alignment = 0;
Kernel: Symbolicate userspace backtraces using ELFLoader. Stash away the ELFLoader used to load an executable in Process so we can use it for symbolicating userspace addresses later on. This will make debugging userspace programs a lot nicer. :^)
2019-05-16 15:18:25 +00:00
OwnPtr<ELFLoader> loader;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
{
// Okay, here comes the sleight of hand, pay close attention..
auto old_regions = move(m_regions);
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
m_regions.append(move(executable_region));
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
loader = make<ELFLoader>(region->vaddr().as_ptr());
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
loader->map_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, bool is_executable, const String& name) -> u8* {
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
ASSERT(size);
Fix all current build warnings in the kernel.
2018-11-09 09:03:21 +00:00
ASSERT(alignment == PAGE_SIZE);
Kernel: Make the Process allocate_region* API's understand "int prot". Instead of having to inspect 'prot' at every call site, make the Process API's take care of that so we can just pass it through.
2019-05-30 14:14:37 +00:00
int prot = 0;
if (is_readable)
prot |= PROT_READ;
if (is_writable)
prot |= PROT_WRITE;
if (is_executable)
prot |= PROT_EXEC;
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
if (!allocate_region_with_vmobject(vaddr, size, vmobject, offset_in_image, String(name), prot))
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
return nullptr;
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
return vaddr.as_ptr();
Teach Process::exec() about the magic of file-backed VMO's. This is really sweet! :^) The four instances of /bin/sh spawned at startup now share their read-only text pages. There are problems and limitations here, and plenty of room for improvement. But it kinda works.
2018-11-08 20:20:09 +00:00
};
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
loader->alloc_section_hook = [&](VirtualAddress vaddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) -> u8* {
Use ELF program headers to load executables smarter. This turned out way better than the old code. ELF loading is now quite straightforward, and we don't need the weird concept of subregions anymore. Next step is to respect the is_writable flag.
2018-11-03 10:28:23 +00:00
ASSERT(size);
Fix all current build warnings in the kernel.
2018-11-09 09:03:21 +00:00
ASSERT(alignment == PAGE_SIZE);
Kernel: Make the Process allocate_region* API's understand "int prot". Instead of having to inspect 'prot' at every call site, make the Process API's take care of that so we can just pass it through.
2019-05-30 14:14:37 +00:00
int prot = 0;
if (is_readable)
prot |= PROT_READ;
if (is_writable)
prot |= PROT_WRITE;
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
if (!allocate_region(vaddr, size, String(name), prot))
return nullptr;
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
return vaddr.as_ptr();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
};
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
loader->tls_section_hook = [&](size_t size, size_t alignment) {
ASSERT(size);
master_tls_region = allocate_region({}, size, String(), PROT_READ | PROT_WRITE);
master_tls_size = size;
master_tls_alignment = alignment;
return master_tls_region->vaddr().as_ptr();
};
Kernel: Symbolicate userspace backtraces using ELFLoader. Stash away the ELFLoader used to load an executable in Process so we can use it for symbolicating userspace addresses later on. This will make debugging userspace programs a lot nicer. :^)
2019-05-16 15:18:25 +00:00
bool success = loader->load();
if (!success || !loader->entry().get()) {
Let PageDirectory have a PhysicalPage for the PDB instead of being the PDB. This is more efficient than using the wasteful kmalloc_aligned() approach to allocation. It also allows much tighter encapsulation of the class.
2018-12-31 13:58:03 +00:00
m_page_directory = move(old_page_directory);
MM: Allocate page tables from a separate set of physical pages. The old approach only worked because of an overpermissive accident. There's now a concept of supervisor physical pages that can be allocated. They all sit in the low 4 MB of physical memory and are identity mapped, shared between all processes, and only ring 0 can access them.
2019-01-01 01:09:43 +00:00
// FIXME: RAII this somehow instead.
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
ASSERT(&current->process() == this);
Fix some bugs in execve() and make sh use it for process launching. Interrupting children of sh now always works with ^C :^)
2018-11-03 01:04:36 +00:00
MM.enter_process_paging_scope(*this);
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
executable_region = m_regions.take_first();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
m_regions = move(old_regions);
Kernel: Load ELF executable pages lazily when possible. This currently only works for "normal" processes created by fork(). It does not work for create_user_process() processes spawned by the kernel, as those are a bit special during construction.
2019-03-27 03:01:15 +00:00
kprintf("do_exec: Failure loading %s\n", path.characters());
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
return -ENOEXEC;
}
Kernel: Do a bit more of do_exec() before disabling interrupts. We definitely need to replace m_executable before clearing interrupts, since otherwise we might call ~Custody() which would make it assert in locking. Also avoid calling FileDescriptor::metadata() repeatedly and just cache the result from the first call. I also added a comment at the point where we've decided to commit to the new executable and follow through with the swap.
2019-05-31 05:02:43 +00:00
// NOTE: At this point, we've committed to the new executable.
Kernel: Symbolicate userspace backtraces using ELFLoader. Stash away the ELFLoader used to load an executable in Process so we can use it for symbolicating userspace addresses later on. This will make debugging userspace programs a lot nicer. :^)
2019-05-16 15:18:25 +00:00
entry_eip = loader->entry().get();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
}
Kernel+SystemMonitor: Prevent userspace access to process ELF image Every process keeps its own ELF executable mapped in memory in case we need to do symbol lookup (for backtraces, etc.) Until now, it was mapped in a way that made it accessible to the program, despite the program not having mapped it itself. I don't really see a need for userspace to have access to this right now, so let's lock things down a little bit. This patch makes it inaccessible to userspace and exposes that fact through /proc/PID/vm (per-region "user_accessible" flag.)
2019-12-15 19:11:57 +00:00
region->set_user_accessible(false);
region->remap();
Kernel: Symbolicate userspace backtraces using ELFLoader. Stash away the ELFLoader used to load an executable in Process so we can use it for symbolicating userspace addresses later on. This will make debugging userspace programs a lot nicer. :^)
2019-05-16 15:18:25 +00:00
m_elf_loader = move(loader);
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_executable = description->custody();
Kernel: Do a bit more of do_exec() before disabling interrupts. We definitely need to replace m_executable before clearing interrupts, since otherwise we might call ~Custody() which would make it assert in locking. Also avoid calling FileDescriptor::metadata() repeatedly and just cache the result from the first call. I also added a comment at the point where we've decided to commit to the new executable and follow through with the swap.
2019-05-31 05:02:43 +00:00
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
// Copy of the master TLS region that we will clone for new threads
Kernel: Make Region single-owner instead of ref-counted This simplifies the ownership model and makes Region easier to reason about. Userspace Regions are now primarily kept by Process::m_regions. Kernel Regions are kept in various OwnPtr<Regions>'s. Regions now only ever get unmapped when they are destroyed.
2019-09-27 12:19:07 +00:00
m_master_tls_region = 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
Kernel: Do a bit more of do_exec() before disabling interrupts. We definitely need to replace m_executable before clearing interrupts, since otherwise we might call ~Custody() which would make it assert in locking. Also avoid calling FileDescriptor::metadata() repeatedly and just cache the result from the first call. I also added a comment at the point where we've decided to commit to the new executable and follow through with the swap.
2019-05-31 05:02:43 +00:00
if (metadata.is_setuid())
m_euid = metadata.uid;
if (metadata.is_setgid())
m_egid = metadata.gid;
Kernel: Symbolicate userspace backtraces using ELFLoader. Stash away the ELFLoader used to load an executable in Process so we can use it for symbolicating userspace addresses later on. This will make debugging userspace programs a lot nicer. :^)
2019-05-16 15:18:25 +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
current->set_default_signal_dispositions();
current->m_signal_mask = 0;
current->m_pending_signals = 0;
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
for (int i = 0; i < m_fds.size(); ++i) {
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
auto& daf = m_fds[i];
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (daf.description && daf.flags & FD_CLOEXEC) {
daf.description->close();
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
daf = {};
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: 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
// FIXME: Should we just make a new Thread here instead?
Thread* new_main_thread = nullptr;
if (&current->process() == this) {
new_main_thread = current;
} else {
for_each_thread([&](auto& thread) {
new_main_thread = &thread;
return IterationDecision::Break;
});
}
ASSERT(new_main_thread);
Kernel: Fix intermittent assertion failure in sys$exec() While setting up the main thread stack for a new process, we'd incur some zero-fill page faults. This was to be expected, since we allocate a huge stack but lazily populate it with physical pages. The problem is that page fault handlers may enable interrupts in order to grab a VMObject lock (or to page in from an inode.) During exec(), a process is reorganizing itself and will be in a very unrunnable state if the scheduler should interrupt it and then later ask it to run again. Which is exactly what happens if the process gets pre-empted while the new stack's zero-fill page fault grabs the lock. This patch fixes the issue by creating new main thread stacks before disabling interrupts and going into the critical part of exec().
2019-12-18 22:03:23 +00:00
// NOTE: We create the new stack before disabling interrupts since it will zero-fault
// and we don't want to deal with faults after this point.
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
u32 new_userspace_esp = new_main_thread->make_userspace_stack_for_main_thread(move(arguments), move(environment));
Kernel: Fix intermittent assertion failure in sys$exec() While setting up the main thread stack for a new process, we'd incur some zero-fill page faults. This was to be expected, since we allocate a huge stack but lazily populate it with physical pages. The problem is that page fault handlers may enable interrupts in order to grab a VMObject lock (or to page in from an inode.) During exec(), a process is reorganizing itself and will be in a very unrunnable state if the scheduler should interrupt it and then later ask it to run again. Which is exactly what happens if the process gets pre-empted while the new stack's zero-fill page fault grabs the lock. This patch fixes the issue by creating new main thread stacks before disabling interrupts and going into the critical part of exec().
2019-12-18 22:03:23 +00:00
Fix race condition in exec(). ...also hook up sys$fstat in the syscall dispatcher.
2018-11-16 23:52:29 +00:00
// We cli() manually here because we don't want to get interrupted between do_exec() and Schedule::yield().
// The reason is that the task redirection we've set up above will be clobbered by the timer IRQ.
// If we used an InterruptDisabler that sti()'d on exit, we might timer tick'd too soon in exec().
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
if (&current->process() == this)
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
cli();
Fix race condition in exec(). ...also hook up sys$fstat in the syscall dispatcher.
2018-11-16 23:52:29 +00:00
Kernel: Fix intermittent assertion failure in sys$exec() While setting up the main thread stack for a new process, we'd incur some zero-fill page faults. This was to be expected, since we allocate a huge stack but lazily populate it with physical pages. The problem is that page fault handlers may enable interrupts in order to grab a VMObject lock (or to page in from an inode.) During exec(), a process is reorganizing itself and will be in a very unrunnable state if the scheduler should interrupt it and then later ask it to run again. Which is exactly what happens if the process gets pre-empted while the new stack's zero-fill page fault grabs the lock. This patch fixes the issue by creating new main thread stacks before disabling interrupts and going into the critical part of exec().
2019-12-18 22:03:23 +00:00
// NOTE: Be careful to not trigger any page faults below!
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
Scheduler::prepare_to_modify_tss(*new_main_thread);
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
Coding style fixes in AK.
2019-01-19 21:53:05 +00:00
m_name = parts.take_last();
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
new_main_thread->set_name(m_name);
auto& tss = new_main_thread->m_tss;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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
u32 old_esp0 = tss.esp0;
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: 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
m_master_tls_size = master_tls_size;
m_master_tls_alignment = master_tls_alignment;
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
new_main_thread->make_thread_specific_region({});
memset(&tss, 0, sizeof(TSS32));
Kernel: Prevent executing I/O instructions in userspace All threads were running with iomapbase=0 in their TSS, which the CPU interprets as "there's an I/O permission bitmap starting at offset 0 into my TSS". Because of that, any bits that were 1 inside the TSS would allow the thread to execute I/O instructions on the port with that bit index. Fix this by always setting the iomapbase to sizeof(TSS32), and also setting the TSS descriptor's limit to sizeof(TSS32), effectively making the I/O permissions bitmap zero-length. This should make it no longer possible to do I/O from userspace. :^)
2020-01-01 16:26:25 +00:00
tss.iomapbase = sizeof(TSS32);
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
tss.eflags = 0x0202;
tss.eip = entry_eip;
tss.cs = 0x1b;
tss.ds = 0x23;
tss.es = 0x23;
tss.fs = 0x23;
tss.gs = thread_specific_selector() | 3;
tss.ss = 0x23;
tss.cr3 = page_directory().cr3();
tss.esp = new_userspace_esp;
tss.ss0 = 0x10;
tss.esp0 = old_esp0;
tss.ss2 = m_pid;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
#ifdef TASK_DEBUG
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
kprintf("Process %u (%s) exec'd %s @ %p\n", pid(), name().characters(), path.characters(), tss.eip);
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
#endif
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
new_main_thread->set_state(Thread::State::Skip1SchedulerPass);
Kernel: Fix a nasty lock bug with exec() Exec doesn't leave through the syscall handler, so it didn't unlock the big_lock. This means that reentering can lock it again, and then another thread could endlessly yield waiting to acquire the lock (futilely). This fixes AudioServer using 100% CPU.
2019-07-17 12:15:13 +00:00
big_lock().unlock_if_locked();
Okay, now *actually* plug the leaks in exec(). I didn't even put the { } properly around everything that would leak. Let's make sure this works correctly by splitting out the work into a helper called do_exec().
2018-11-09 16:59:14 +00:00
return 0;
}
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
KResultOr<Vector<String>> Process::find_shebang_interpreter_for_executable(const String& executable_path)
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
{
// FIXME: It's a bit sad that we'll open the executable twice (in case there's no shebang)
// Maybe we can find a way to plumb this opened FileDescription to the rest of the
// exec implementation..
auto result = VFS::the().open(executable_path, 0, 0, current_directory());
if (result.is_error())
return result.error();
auto description = result.value();
auto metadata = description->metadata();
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
if (!metadata.may_execute(*this))
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
return KResult(-EACCES);
if (metadata.size < 3)
return KResult(-ENOEXEC);
char first_page[PAGE_SIZE];
int nread = description->read((u8*)&first_page, sizeof(first_page));
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
int word_start = 2;
int word_length = 0;
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
if (nread > 2 && first_page[0] == '#' && first_page[1] == '!') {
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
Vector<String> interpreter_words;
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
for (int i = 2; i < nread; ++i) {
if (first_page[i] == '\n') {
break;
}
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
if (first_page[i] != ' ') {
++word_length;
}
if (first_page[i] == ' ') {
if (word_length > 0) {
interpreter_words.append(String(&first_page[word_start], word_length));
}
word_length = 0;
word_start = i + 1;
}
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
}
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
if (word_length > 0)
interpreter_words.append(String(&first_page[word_start], word_length));
if (!interpreter_words.is_empty())
return interpreter_words;
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
}
return KResult(-ENOEXEC);
}
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
int Process::exec(String path, Vector<String> arguments, Vector<String> environment)
Okay, now *actually* plug the leaks in exec(). I didn't even put the { } properly around everything that would leak. Let's make sure this works correctly by splitting out the work into a helper called do_exec().
2018-11-09 16:59:14 +00:00
{
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
auto result = find_shebang_interpreter_for_executable(path);
Kernel: Support passing arguments in shebangged scripts Add the ability to both pass arguments to scripts with shebangs (./script argument1 argument2) and to specify them in the shebang line (#!/usr/local/bin/bash -x -e) Fixes #585
2019-10-27 09:42:07 +00:00
if (!result.is_error()) {
Vector<String> new_arguments(result.value());
new_arguments.append(path);
arguments.remove(0);
new_arguments.append(move(arguments));
return exec(result.value().first(), move(new_arguments), move(environment));
}
Kernel: Implement shebang executables ("#!/bin/sh") This patch makes it possible to *run* text files that start with the characters "#!" followed by an interpreter. I've tested this with both the Serenity built-in shell and the Bash shell, and it works as expected. :^)
2019-09-15 09:47:21 +00:00
Okay, now *actually* plug the leaks in exec(). I didn't even put the { } properly around everything that would leak. Let's make sure this works correctly by splitting out the work into a helper called do_exec().
2018-11-09 16:59:14 +00:00
// The bulk of exec() is done by do_exec(), which ensures that all locals
// are cleaned up by the time we yield-teleport below.
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
int rc = do_exec(move(path), move(arguments), move(environment));
Okay, now *actually* plug the leaks in exec(). I didn't even put the { } properly around everything that would leak. Let's make sure this works correctly by splitting out the work into a helper called do_exec().
2018-11-09 16:59:14 +00:00
if (rc < 0)
return rc;
Finally unbreak the colonel process and make it the true idle process.
2018-11-07 22:13:38 +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
if (&current->process() == this) {
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
Scheduler::yield();
Fix VMO leak in Process::exec(). Gotta make sure things get cleaned up before we yield-teleport in exec(). Also VMOs and regions are now viewable through /proc/mm and /proc/regions.
2018-11-08 21:24:02 +00:00
ASSERT_NOT_REACHED();
Finally unbreak the colonel process and make it the true idle process.
2018-11-07 22:13:38 +00:00
}
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
return 0;
}
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
int Process::sys$execve(const char* filename, const char** argv, const char** envp)
{
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
// NOTE: Be extremely careful with allocating any kernel memory in exec().
// On success, the kernel stack will be lost.
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(filename))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
LibC: Add execvpe() and make execvp()'ed children inherit environment.
2019-04-26 01:16:26 +00:00
if (!*filename)
return -ENOENT;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
if (argv) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_typed(argv))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
for (size_t i = 0; argv[i]; ++i) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(argv[i]))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
}
}
if (envp) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_typed(envp))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
for (size_t i = 0; envp[i]; ++i) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(envp[i]))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
}
}
String path(filename);
Vector<String> arguments;
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
Vector<String> environment;
{
auto parts = path.split('/');
if (argv) {
for (size_t i = 0; argv[i]; ++i) {
arguments.append(argv[i]);
}
} else {
arguments.append(parts.last());
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
}
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
if (envp) {
for (size_t i = 0; envp[i]; ++i)
environment.append(envp[i]);
}
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +00:00
}
Kernel: Fix String leaks in exec(). When the kernel performs a successful exec(), whatever was on the kernel stack for that process before goes away. For this reason, we need to make sure we don't have any stack objects holding onto kmalloc memory.
2019-02-17 09:18:25 +00:00
int rc = exec(move(path), move(arguments), move(environment));
Finally unbreak the colonel process and make it the true idle process.
2018-11-07 22:13:38 +00:00
ASSERT(rc < 0); // We should never continue after a successful exec!
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
return rc;
Factor out the "non-syscall" parts of sys$execve() into exec(). ..to prepare for sharing code with createUserProcess().
2018-11-03 09:20:23 +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
Process* Process::create_user_process(Thread*& first_thread, const String& path, uid_t uid, gid_t gid, pid_t parent_pid, int& error, Vector<String>&& arguments, Vector<String>&& environment, TTY* tty)
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +00:00
{
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
// FIXME: Don't split() the path twice (sys$spawn also does it...)
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +00:00
auto parts = path.split('/');
Yet another pass of style fixes.
2018-12-21 01:10:45 +00:00
if (arguments.is_empty()) {
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
arguments.append(parts.last());
Implement errno in LibC. This also meant I had to implement BSS (SHT_NOBITS) sections in ELFLoader. I also added an strerror() so we can print out what the errors are.
2018-10-25 10:06:00 +00:00
}
AK: Rename RetainPtr => RefPtr and Retained => NonnullRefPtr.
2019-06-21 16:37:47 +00:00
RefPtr<Custody> cwd;
Implement sys$chdir() and teach sh+ls to cd around and browse different dirs.
2018-10-26 12:24:11 +00:00
{
InterruptDisabler disabler;
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
if (auto* parent = Process::from_pid(parent_pid))
Kernel: Remove use of copy_ref() in favor of regular RefPtr copies. This is obviously more readable. If we ever run into a situation where ref count churn is actually causing trouble in the future, we can deal with it then. For now, let's keep it simple. :^)
2019-07-11 13:38:47 +00:00
cwd = parent->m_cwd;
Add some basic field width support to printf(). Use it to make "ls" output a bit better. Also sys$spawn now fails with EACCES if the path is not a file that's executable by the current uid/gid.
2018-10-27 14:43:03 +00:00
}
Get rid of Vnode concept. We already have an abstraction between Process and Inode/CharacterDevice/FIFO and it's called FileDescriptor. :^)
2019-01-16 11:57:07 +00:00
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
if (!cwd)
FileSystem: Port most of the code over to using custodies. The current working directory is now stored as a custody. Likewise for a process executable file. This unbreaks /proc/PID/fd which has not been working since we made the filesystem bigger. This still needs a bunch of work, for instance when renaming or removing a file somewhere, we have to update the relevant custody links.
2019-05-30 16:58:59 +00:00
cwd = VFS::the().root_custody();
Add some basic field width support to printf(). Use it to make "ls" output a bit better. Also sys$spawn now fails with EACCES if the path is not a file that's executable by the current uid/gid.
2018-10-27 14:43:03 +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
auto* process = new Process(first_thread, parts.take_last(), uid, gid, parent_pid, Ring3, move(cwd), nullptr, tty);
Implement argc/argv support for spawned tasks. Celebrate the new functionality with a simple /bin/cat implementation. :^)
2018-10-26 09:16:56 +00:00
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
error = process->exec(path, move(arguments), move(environment));
Process::create_user_process() shouldn't leak a process if exec() fails.
2018-12-26 20:04:27 +00:00
if (error != 0) {
delete process;
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +00:00
return nullptr;
Process::create_user_process() shouldn't leak a process if exec() fails.
2018-12-26 20:04:27 +00:00
}
More work on per-process page directories. It basically works now! I spent some time stuck on a problem where processes would clobber each other's stacks. Took me a moment to figure out that their stacks were allocated in the sub-4MB linear address range which is shared between all processes. Oops!
2018-11-01 10:30:48 +00:00
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
{
InterruptDisabler disabler;
g_processes->prepend(process);
}
Add a simplified waitpid() so that sh can wait on spawned commands.
2018-10-23 22:20:34 +00:00
#ifdef TASK_DEBUG
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
kprintf("Process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), first_thread->tss().eip);
Add a simplified waitpid() so that sh can wait on spawned commands.
2018-10-23 22:20:34 +00:00
#endif
Implement errno in LibC. This also meant I had to implement BSS (SHT_NOBITS) sections in ELFLoader. I also added an strerror() so we can print out what the errors are.
2018-10-25 10:06:00 +00:00
error = 0;
Share code between spawn() and exec() implementations. Okay, now there's only one ELF loading client in the process launch code.
2018-11-03 09:49:13 +00:00
return process;
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +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
Process* Process::create_kernel_process(Thread*& first_thread, String&& name, void (*e)())
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +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
auto* process = new Process(first_thread, move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0);
first_thread->tss().eip = (u32)e;
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +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
if (process->pid() != 0) {
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
InterruptDisabler disabler;
g_processes->prepend(process);
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +00:00
#ifdef TASK_DEBUG
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
kprintf("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), first_thread->tss().eip);
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +00:00
#endif
}
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
first_thread->set_state(Thread::State::Runnable);
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
return process;
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +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
Process::Process(Thread*& first_thread, const String& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent)
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +00:00
: m_name(move(name))
Kernel: Make TID's be unique PID's This is a little strange, but it's how I understand things should work. The first thread in a new process now has TID == PID. Additional threads subsequently spawned in that process all have unique TID's generated by the PID allocator. TIDs are now globally unique.
2019-12-22 10:51:24 +00:00
, m_pid(allocate_pid())
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +00:00
, m_uid(uid)
, m_gid(gid)
Add geteuid() and getegid(). There's no support for set-uid or set-gid executables yet so these don't actually do anything. It's just nice to get the boilerplate stuff in.
2018-11-05 14:04:19 +00:00
, m_euid(uid)
, m_egid(gid)
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +00:00
, m_ring(ring)
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
, m_executable(move(executable))
, m_cwd(move(cwd))
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
, m_tty(tty)
Add getppid().
2018-11-06 12:33:06 +00:00
, m_ppid(ppid)
Launching an arbitrary ELF executable from disk works! :^) This is so cool! It's a bit messy now with two Task constructors, but eventually they should fold into a single constructor somehow.
2018-10-22 13:42:39 +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
dbgprintf("Process: New process PID=%u with name=%s\n", m_pid, m_name.characters());
Kernel: Add mapping from page directory base (PDB) to PageDirectory This allows the page fault code to find the owning PageDirectory and corresponding process for faulting regions. The mapping is implemented as a global hash map right now, which is definitely not optimal. We can come up with something better when it becomes necessary.
2019-08-06 09:19:16 +00:00
m_page_directory = PageDirectory::create_for_userspace(*this, fork_parent ? &fork_parent->page_directory().range_allocator() : nullptr);
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
#ifdef MM_DEBUG
dbgprintf("Process %u ctor: PD=%x created\n", pid(), m_page_directory.ptr());
#endif
Kernel: Ignore SIGCHLD by default. Also use an enum for the rather-confusing return value in dispatch_signal(). I will go through the rest of the signals and set them up with the appropriate default dispositions at some other point.
2019-02-04 13:06:38 +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
// NOTE: fork() doesn't clone all threads; the thread that called fork() becomes the main thread in the new process.
if (fork_parent)
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
first_thread = current->clone(*this);
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
else
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
first_thread = new Thread(*this);
Kernel: Implement lazy FPU state restore.
2019-01-25 06:52:44 +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
//m_gids.set(m_gid);
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
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
if (fork_parent) {
m_sid = fork_parent->m_sid;
m_pgid = fork_parent->m_pgid;
} else {
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
// FIXME: Use a ProcessHandle? Presumably we're executing *IN* the parent right now though..
InterruptDisabler disabler;
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
if (auto* parent = Process::from_pid(m_ppid)) {
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
m_sid = parent->m_sid;
m_pgid = parent->m_pgid;
}
}
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
if (fork_parent) {
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
m_fds.resize(fork_parent->m_fds.size());
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
for (int i = 0; i < fork_parent->m_fds.size(); ++i) {
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!fork_parent->m_fds[i].description)
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
continue;
#ifdef FORK_DEBUG
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
dbgprintf("fork: cloning fd %u... (%p) istty? %u\n", i, fork_parent->m_fds[i].description.ptr(), fork_parent->m_fds[i].description->is_tty());
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
#endif
Kernel: Fix cloning file descriptions on fork After a fork, the parent and the child are supposed to share the same file description. For example, modifying the current offset of a file description is visible in both of them.
2019-08-11 13:07:47 +00:00
m_fds[i] = fork_parent->m_fds[i];
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
}
} else {
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
m_fds.resize(m_max_open_file_descriptors);
Kernel: Make sure processes always start out with fds 0, 1 and 2 open. If we don't have a TTY for the process, fall back to /dev/null.
2019-02-12 10:25:25 +00:00
auto& device_to_use_as_tty = tty ? (CharacterDevice&)*tty : NullDevice::the();
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
m_fds[0].set(*device_to_use_as_tty.open(O_RDONLY).value());
m_fds[1].set(*device_to_use_as_tty.open(O_WRONLY).value());
m_fds[2].set(*device_to_use_as_tty.open(O_WRONLY).value());
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: Respect the process umask in open() and mkdir().
2019-02-22 01:39:13 +00:00
if (fork_parent) {
m_sid = fork_parent->m_sid;
m_pgid = fork_parent->m_pgid;
m_umask = fork_parent->m_umask;
}
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
}
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::~Process()
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: 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
dbgprintf("~Process{%p} name=%s pid=%d, m_fds=%d, m_thread_count=%u\n", this, m_name.characters(), pid(), m_fds.size(), m_thread_count);
ASSERT(thread_count() == 0);
Add Regions concept to Task.
2018-10-18 12:53:00 +00:00
}
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
void Process::dump_regions()
Add Regions concept to Task.
2018-10-18 12:53:00 +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
kprintf("Process %s(%u) regions:\n", name().characters(), pid());
Kernel: Show region access bits (R/W/X) in crash dump region lists It's pretty helpful to be able to see the various access bits for each region in a crash dump. :^)
2019-08-12 17:37:28 +00:00
kprintf("BEGIN END SIZE ACCESS NAME\n");
Add Regions concept to Task.
2018-10-18 12:53:00 +00:00
for (auto& region : m_regions) {
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
kprintf("%08x -- %08x %08x %c%c%c%c%c%c %s\n",
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
region.vaddr().get(),
region.vaddr().offset(region.size() - 1).get(),
region.size(),
Kernel: Show region access bits (R/W/X) in crash dump region lists It's pretty helpful to be able to see the various access bits for each region in a crash dump. :^)
2019-08-12 17:37:28 +00:00
region.is_readable() ? 'R' : ' ',
region.is_writable() ? 'W' : ' ',
region.is_executable() ? 'X' : ' ',
Kernel: Implement some basic stack pointer validation VM regions can now be marked as stack regions, which is then validated on syscall, and on page fault. If a thread is caught with its stack pointer pointing into anything that's *not* a Region with its stack bit set, we'll crash the whole process with SIGSTKFLT. Userspace must now allocate custom stacks by using mmap() with the new MAP_STACK flag. This mechanism was first introduced in OpenBSD, and now we have it too, yay! :^)
2019-11-17 11:11:43 +00:00
region.is_shared() ? 'S' : ' ',
region.is_stack() ? 'T' : ' ',
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
region.vmobject().is_purgeable() ? 'P' : ' ',
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
region.name().characters());
Add Regions concept to Task.
2018-10-18 12:53:00 +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
}
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
void Process::sys$exit(int status)
Add a sys$exit and make init_stage2 call it when finished.
2018-10-22 09:43:55 +00:00
{
cli();
Add a simplified waitpid() so that sh can wait on spawned commands.
2018-10-23 22:20:34 +00:00
#ifdef TASK_DEBUG
Add a sys$exit and make init_stage2 call it when finished.
2018-10-22 09:43:55 +00:00
kprintf("sys$exit: %s(%u) exit with status %d\n", name().characters(), pid(), status);
Add a simplified waitpid() so that sh can wait on spawned commands.
2018-10-23 22:20:34 +00:00
#endif
Add a sys$exit and make init_stage2 call it when finished.
2018-10-22 09:43:55 +00:00
Kernel: Simplify dump_backtrace() API for clients. It makes no sense that clients had to worry about whether or not KSyms were loaded.
2019-05-16 11:41:16 +00:00
dump_backtrace();
Kernel: Dump backtrace on exit() syscall. This makes assertion failures a lot more pleasant to investigate.
2019-05-06 19:48:48 +00:00
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
m_termination_status = status;
m_termination_signal = 0;
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
die();
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
current->die_if_needed();
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
ASSERT_NOT_REACHED();
Add a sys$exit and make init_stage2 call it when finished.
2018-10-22 09:43:55 +00:00
}
Kernel: Stop hardcoding syscall in signal trampoline. We now no longer hardcode the sigreturn syscall in the signal trampoline. Because of the way inline asm inputs work, I've had to enclose the trampoline in the function signal_trampoline_dummy.
2019-09-17 13:41:42 +00:00
void signal_trampoline_dummy(void)
{
// The trampoline preserves the current eax, pushes the signal code and
// then calls the signal handler. We do this because, when interrupting a
// blocking syscall, that syscall may return some special error code in eax;
// This error code would likely be overwritten by the signal handler, so it's
// neccessary to preserve it here.
asm(
".intel_syntax noprefix\n"
"asm_signal_trampoline:\n"
"push ebp\n"
"mov ebp, esp\n"
"push eax\n" // we have to store eax 'cause it might be the return value from a syscall
"sub esp, 4\n" // align the stack to 16 bytes
"mov eax, [ebp+12]\n" // push the signal code
"push eax\n"
"call [ebp+8]\n" // call the signal handler
"add esp, 8\n"
"mov eax, %P0\n"
"int 0x82\n" // sigreturn syscall
"asm_signal_trampoline_end:\n"
".att_syntax" ::"i"(Syscall::SC_sigreturn));
}
Kernel: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
extern "C" void asm_signal_trampoline(void);
extern "C" void asm_signal_trampoline_end(void);
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
void create_signal_trampolines()
Kernel: More signal handling improvements. Finally fixed the weird flaky crashing when resizing Terminal windows. It was because we were dispatching a signal to "current" from the scheduler. Yet another thing I dislike about even having a "current" process while we're in the scheduler. Not sure yet how to fix this. Let the signal handler's kernel stack be a kmalloc() allocation for now. Once we can do allocation of consecutive physical pages in the supervisor memory region, we can use that for all types of kernel stacks.
2019-03-05 11:50:55 +00:00
{
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
InterruptDisabler disabler;
// NOTE: We leak this region.
Kernel: Make kernel memory regions be non-executable by default From now on, you'll have to request executable memory specifically if you want some.
2019-12-25 21:41:34 +00:00
auto* trampoline_region = MM.allocate_user_accessible_kernel_region(PAGE_SIZE, "Signal trampolines", Region::Access::Read | Region::Access::Write | Region::Access::Execute).leak_ptr();
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
g_return_to_ring3_from_signal_trampoline = trampoline_region->vaddr();
Kernel: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
u8* trampoline = (u8*)asm_signal_trampoline;
u8* trampoline_end = (u8*)asm_signal_trampoline_end;
size_t trampoline_size = trampoline_end - trampoline;
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
u8* code_ptr = (u8*)trampoline_region->vaddr().as_ptr();
Kernel: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
memcpy(code_ptr, trampoline, trampoline_size);
Kernel: Share the "return to ring 0/3 from signal" trampolines globally. Generate a special page containing the "return from signal" trampoline code on startup and then route signalled threads to it. This avoids a page allocation in every process that ever receives a signal.
2019-07-19 15:01:16 +00:00
trampoline_region->set_writable(false);
Kernel: Teach Region how to remap itself Now remapping (i.e flushing kernel metadata to the CPU page tables) is done by simply calling Region::remap().
2019-11-03 19:59:54 +00:00
trampoline_region->remap();
Kernel: More signal handling improvements. Finally fixed the weird flaky crashing when resizing Terminal windows. It was because we were dispatching a signal to "current" from the scheduler. Yet another thing I dislike about even having a "current" process while we're in the scheduler. Not sure yet how to fix this. Let the signal handler's kernel stack be a kmalloc() allocation for now. Once we can do allocation of consecutive physical pages in the supervisor memory region, we can use that for all types of kernel stacks.
2019-03-05 11:50:55 +00:00
}
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
void create_kernel_info_page()
{
Kernel: Make kernel memory regions be non-executable by default From now on, you'll have to request executable memory specifically if you want some.
2019-12-25 21:41:34 +00:00
auto* info_page_region_for_userspace = MM.allocate_user_accessible_kernel_region(PAGE_SIZE, "Kernel info page", Region::Access::Read).leak_ptr();
auto* info_page_region_for_kernel = MM.allocate_kernel_region_with_vmobject(info_page_region_for_userspace->vmobject(), PAGE_SIZE, "Kernel info page", Region::Access::Read | Region::Access::Write).leak_ptr();
Kernel: Make sure the kernel info page is read-only for userspace To enforce this, we create two separate mappings of the same underlying physical page. A writable mapping for the kernel, and a read-only one for userspace (the one returned by sys$get_kernel_info_page.)
2019-12-15 21:21:28 +00:00
s_info_page_address_for_userspace = info_page_region_for_userspace->vaddr();
s_info_page_address_for_kernel = info_page_region_for_kernel->vaddr();
memset(s_info_page_address_for_kernel.as_ptr(), 0, PAGE_SIZE);
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29: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
int Process::sys$restore_signal_mask(u32 mask)
Kernel: Block a signal from being dispatched again until handler returns. We don't handle nesting yet, but this is a step in the right direction.
2019-03-05 09:34:08 +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
current->m_signal_mask = mask;
Kernel: Block a signal from being dispatched again until handler returns. We don't handle nesting yet, but this is a step in the right direction.
2019-03-05 09:34:08 +00:00
return 0;
}
Kernel: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
int Process::sys$sigreturn(RegisterDump& registers)
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: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
//Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
u32* stack_ptr = (u32*)registers.esp_if_crossRing;
u32 smuggled_eax = *stack_ptr;
//pop the stored eax, ebp, return address, handler and signal code
stack_ptr += 5;
current->m_signal_mask = *stack_ptr;
stack_ptr++;
Kernel: Add exception_code to RegisterDump. Added the exception_code field to RegisterDump, removing the need for RegisterDumpWithExceptionCode. To accomplish this, I had to push a dummy exception code during some interrupt entries to properly pad out the RegisterDump. Note that we also needed to change some code in sys$sigreturn to deal with the new RegisterDump layout.
2019-10-04 14:31:34 +00:00
//pop edi, esi, ebp, esp, ebx, edx, ecx and eax
memcpy(&registers.edi, stack_ptr, 8 * sizeof(u32));
stack_ptr += 8;
registers.eip = *stack_ptr;
stack_ptr++;
Kernel: Use user stack for signal handlers. This commit drastically changes how signals are handled. In the case that an unblocked thread is signaled it works much in the same way as previously. However, when a blocking syscall is interrupted, we set up the signal trampoline on the user stack, complete the blocking syscall, return down the kernel stack and then jump to the handler. This means that from the kernel stack's perspective, we only ever get one system call deep. The signal trampoline has also been changed in order to properly store the return value from system calls. This is necessary due to the new way we exit from signaled system calls.
2019-09-04 13:14:54 +00:00
registers.eflags = *stack_ptr;
stack_ptr++;
registers.esp_if_crossRing = registers.esp;
return smuggled_eax;
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +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 Process::crash(int signal, u32 eip)
Actually destroy tasks after they crash.
2018-10-17 22:26:30 +00:00
{
Add a few more InterruptDisablers.
2018-10-25 08:33:10 +00:00
ASSERT_INTERRUPTS_DISABLED();
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
ASSERT(!is_dead());
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
ASSERT(&current->process() == this);
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
Kernel: Symbolicate the crash address too, not just the call stack. Also print it in shiny red to make it extra easy to spot. :^) Fixes #244.
2019-06-19 16:50:02 +00:00
if (m_elf_loader && ksyms_ready)
dbgprintf("\033[31;1m%p %s\033[0m\n", eip, m_elf_loader->symbolicate(eip).characters());
Kernel: Always dump_backtrace() on process crash.
2019-05-16 17:49:48 +00:00
dump_backtrace();
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
m_termination_signal = signal;
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
dump_regions();
Process: Dump regions when a ring0 process crashes.
2019-02-08 08:45:53 +00:00
ASSERT(is_ring3());
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
die();
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
// We can not return from here, as there is nowhere
// to unwind to, so die right away.
current->die_if_needed();
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
ASSERT_NOT_REACHED();
Actually destroy tasks after they crash.
2018-10-17 22:26:30 +00:00
}
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
Process* Process::from_pid(pid_t pid)
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
{
Add ASSERT_INTERRUPTS_DISABLED in Task::fromPID().
2018-10-26 13:11:29 +00:00
ASSERT_INTERRUPTS_DISABLED();
Kernel: Use some more InlineLinkedList range-for iteration
2019-08-08 12:40:13 +00:00
for (auto& process : *g_processes) {
if (process.pid() == pid)
return &process;
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
}
return nullptr;
}
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 07:36:51 +00:00
FileDescription* Process::file_description(int fd)
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
{
if (fd < 0)
return nullptr;
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
if (fd < m_fds.size())
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return m_fds[fd].description.ptr();
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
return nullptr;
}
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 07:36:51 +00:00
const FileDescription* Process::file_description(int fd) const
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
{
if (fd < 0)
return nullptr;
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
if (fd < m_fds.size())
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return m_fds[fd].description.ptr();
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
return nullptr;
}
Kernel: Expose blocking and cloexec fd flags in ProcFS
2019-09-28 20:00:38 +00:00
int Process::fd_flags(int fd) const
{
if (fd < 0)
return -1;
if (fd < m_fds.size())
return m_fds[fd].flags;
return -1;
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
ssize_t Process::sys$get_dir_entries(int fd, void* buffer, ssize_t size)
Lots of hacking to make a very simple "ls" utility. I added a dead-simple malloc that only allows allocations < 4096 bytes. It just forwards the request to mmap() every time. I also added simplified versions of opendir() and readdir().
2018-10-24 10:43:52 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
if (!validate_write(buffer, size))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return -EBADF;
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
return description->get_dir_entries((u8*)buffer, size);
Lots of hacking to make a very simple "ls" utility. I added a dead-simple malloc that only allows allocations < 4096 bytes. It just forwards the request to mmap() every time. I also added simplified versions of opendir() and readdir().
2018-10-24 10:43:52 +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
int Process::sys$lseek(int fd, off_t offset, int whence)
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: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Enough compatibility work to make figlet build and run! I ran out of steam writing library routines and imported two BSD-licensed libc routines: sscanf() and getopt(). I will most likely rewrite them sooner or later. For now I just wanted to see figlet running.
2018-10-31 16:50:43 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->seek(offset, whence);
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: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
int Process::sys$ttyname_r(int fd, char* buffer, ssize_t size)
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
if (!validate_write(buffer, size))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_tty())
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return -ENOTTY;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto tty_name = description->tty()->tty_name();
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if ((size_t)size < tty_name.length() + 1)
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return -ERANGE;
Kernel: Keep TTY names in character buffers instead of Strings Just going over some little unnecessary little kmalloc allocations.
2019-10-18 12:13:43 +00:00
memcpy(buffer, tty_name.characters_without_null_termination(), tty_name.length());
buffer[tty_name.length()] = '\0';
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return 0;
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
int Process::sys$ptsname_r(int fd, char* buffer, ssize_t size)
Add basic PTY support. For now, there are four hard-coded PTYs: /dev/pt{m,s}[0123] Use this in the Terminal to open a pty pair and spawn a shell.
2019-01-15 05:30:19 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Add basic PTY support. For now, there are four hard-coded PTYs: /dev/pt{m,s}[0123] Use this in the Terminal to open a pty pair and spawn a shell.
2019-01-15 05:30:19 +00:00
if (!validate_write(buffer, size))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Add basic PTY support. For now, there are four hard-coded PTYs: /dev/pt{m,s}[0123] Use this in the Terminal to open a pty pair and spawn a shell.
2019-01-15 05:30:19 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* master_pty = description->master_pty();
Add basic PTY support. For now, there are four hard-coded PTYs: /dev/pt{m,s}[0123] Use this in the Terminal to open a pty pair and spawn a shell.
2019-01-15 05:30:19 +00:00
if (!master_pty)
return -ENOTTY;
auto pts_name = master_pty->pts_name();
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if ((size_t)size < pts_name.length() + 1)
Add basic PTY support. For now, there are four hard-coded PTYs: /dev/pt{m,s}[0123] Use this in the Terminal to open a pty pair and spawn a shell.
2019-01-15 05:30:19 +00:00
return -ERANGE;
strcpy(buffer, pts_name.characters());
return 0;
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
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
{
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
if (iov_count < 0)
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
return -EINVAL;
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
if (!validate_read_typed(iov, iov_count))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
Kernel: writev() should fail with EINVAL if total length > INT32_MAX
2020-01-02 12:01:41 +00:00
u64 total_length = 0;
for (int i = 0; i < iov_count; ++i) {
total_length += iov[i].iov_len;
if (total_length > INT32_MAX)
return -EINVAL;
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
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
return -EBADF;
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
if (!description->is_writable())
return -EBADF;
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
int nwritten = 0;
for (int i = 0; i < iov_count; ++i) {
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
int rc = do_write(*description, (const u8*)iov[i].iov_base, iov[i].iov_len);
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
if (rc < 0) {
if (nwritten == 0)
return rc;
return nwritten;
}
nwritten += rc;
}
return nwritten;
}
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
ssize_t Process::do_write(FileDescription& description, const u8* data, int data_size)
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
{
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
ssize_t nwritten = 0;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description.is_blocking()) {
if (!description.can_write())
Kernel: Check can_write for blocking write This way the socket write buffer sizes are respected, and things that exceed them get sent EAGAIN.
2019-05-19 08:25:05 +00:00
return -EAGAIN;
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (description.should_append()) {
Kernel: Support O_APPEND As per the manpage, this acts as a transparent lseek() before write.
2019-05-25 23:18:04 +00:00
#ifdef IO_DEBUG
dbgprintf("seeking to end (O_APPEND)\n");
#endif
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description.seek(0, SEEK_END);
Kernel: Support O_APPEND As per the manpage, this acts as a transparent lseek() before write.
2019-05-25 23:18:04 +00:00
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
while (nwritten < data_size) {
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#ifdef IO_DEBUG
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
dbgprintf("while %u < %u\n", nwritten, size);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#endif
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description.can_write()) {
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#ifdef IO_DEBUG
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
dbgprintf("block write on %d\n", fd);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#endif
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
if (current->block<Thread::WriteBlocker>(description) == Thread::BlockResult::InterruptedBySignal) {
if (nwritten == 0)
return -EINTR;
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
}
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
ssize_t rc = description.write(data + nwritten, data_size - nwritten);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#ifdef IO_DEBUG
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
dbgprintf(" -> write returned %d\n", rc);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
#endif
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
if (rc < 0) {
// FIXME: Support returning partial nwritten with errno.
ASSERT(nwritten == 0);
return rc;
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
if (rc == 0)
break;
nwritten += rc;
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
}
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
return nwritten;
}
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
ssize_t Process::sys$write(int fd, const u8* data, ssize_t size)
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
{
if (size < 0)
return -EINVAL;
if (size == 0)
return 0;
if (!validate_read(data, size))
return -EFAULT;
#ifdef DEBUG_IO
dbgprintf("%s(%u): sys$write(%d, %p, %u)\n", name().characters(), pid(), fd, data, size);
#endif
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Kernel: Add a writev() syscall for writing multiple buffers in one go. We then use this immediately in the WindowServer/LibGUI communication in order to send both message + optional "extra data" with a single syscall.
2019-05-10 01:19:25 +00:00
return -EBADF;
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
if (!description->is_writable())
return -EBADF;
Kernel: Don't interrupt short writes Remove explicit checking for pending signals from writing code paths, since this is handled automatically when blocking, and should not happen if the write() call is "short", i.e. doesn't block. All the other syscalls already work like this. Fixes https://github.com/SerenityOS/serenity/issues/797
2019-11-19 12:33:08 +00:00
return do_write(*description, data, size);
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
ssize_t Process::sys$read(int fd, u8* buffer, ssize_t size)
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: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Kernel: "Succeed" quietly for zero-length read() and write().
2019-04-27 14:17:24 +00:00
if (size == 0)
return 0;
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (!validate_write(buffer, size))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Lots of hacking: - Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
2018-10-23 08:12:50 +00:00
#ifdef DEBUG_IO
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
dbgprintf("%s(%u) sys$read(%d, %p, %u)\n", name().characters(), pid(), fd, buffer, size);
Lots of hacking: - Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
2018-10-23 08:12:50 +00:00
#endif
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
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
return -EBADF;
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
if (!description->is_readable())
return -EBADF;
Kernel: Return error when attempting to read from a directory. We now return EISDIR whenever a program attempts to call sys$read on a directory. Previously, attempting to read a directory could either return junk data or, in the case of /proc/, cause a kernel panic.
2019-10-24 13:46:31 +00:00
if (description->is_directory())
return -EISDIR;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (description->is_blocking()) {
if (!description->can_read()) {
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
if (current->block<Thread::ReadBlocker>(*description) == Thread::BlockResult::InterruptedBySignal)
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
return -EINTR;
Implement a basic way for read() to block. FileHandle gets a hasDataAvailableForRead() getter. If this returns true in sys$read(), the task will block(BlockedRead) + yield. The fd blocked on is stored in Task::m_fdBlockedOnRead. The scheduler then looks at the state of that fd during the unblock phase. This makes "sh" restful. :^) There's still some problem with the kernel not surviving the colonel task getting scheduled. I need to figure that out and fix it.
2018-10-25 11:07:59 +00:00
}
}
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->read(buffer, size);
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
}
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
int Process::sys$close(int fd)
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: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 08:33:37 +00:00
#ifdef DEBUG_IO
dbgprintf("%s(%u) sys$close(%d) %p\n", name().characters(), pid(), fd, description);
#endif
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description)
Add sys$ttyname_r and ttyname_r() + ttyname(). And print a greeting when sh starts up so we know which TTY we're on.
2018-10-30 21:03:02 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
int rc = description->close();
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
m_fds[fd] = {};
Add a /proc/PID/fds text files that lists all the fds open in a process.
2018-11-01 13:00:28 +00:00
return rc;
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: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$utime(const char* pathname, const utimbuf* buf)
Implement utime() along with a naive /bin/touch. This synchronous approach to inodes is silly, obviously. I need to rework it so that the in-memory CoreInode object is the canonical inode, and then we just need a sync() that flushes pending changes to disk.
2018-12-19 20:14:55 +00:00
{
if (!validate_read_str(pathname))
return -EFAULT;
if (buf && !validate_read_typed(buf))
return -EFAULT;
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
time_t atime;
time_t mtime;
Implement utime() along with a naive /bin/touch. This synchronous approach to inodes is silly, obviously. I need to rework it so that the in-memory CoreInode object is the canonical inode, and then we just need a sync() that flushes pending changes to disk.
2018-12-19 20:14:55 +00:00
if (buf) {
atime = buf->actime;
mtime = buf->modtime;
} else {
Kernel: Do timekeeping manually instead of asking the RTC all the time. This introduces a tiny amount of timer drift which I will have to fix somehow eventually, but it's a huge improvement in timing consistency as we no longer suddenly jump from e.g 10:45:49.123 to 10:45:50.000.
2019-03-25 01:06:57 +00:00
struct timeval now;
kgettimeofday(now);
mtime = now.tv_sec;
atime = now.tv_sec;
Implement utime() along with a naive /bin/touch. This synchronous approach to inodes is silly, obviously. I need to rework it so that the in-memory CoreInode object is the canonical inode, and then we just need a sync() that flushes pending changes to disk.
2018-12-19 20:14:55 +00:00
}
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().utime(StringView(pathname), current_directory(), atime, mtime);
Implement utime() along with a naive /bin/touch. This synchronous approach to inodes is silly, obviously. I need to rework it so that the in-memory CoreInode object is the canonical inode, and then we just need a sync() that flushes pending changes to disk.
2018-12-19 20:14:55 +00:00
}
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
int Process::sys$access(const char* pathname, int mode)
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(pathname))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().access(StringView(pathname), mode, current_directory());
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +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
int Process::sys$fcntl(int fd, int cmd, u32 arg)
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 09:38:33 +00:00
{
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
(void)cmd;
(void)arg;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
dbgprintf("sys$fcntl: fd=%d, cmd=%d, arg=%u\n", fd, cmd, arg);
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 09:38:33 +00:00
return -EBADF;
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 07:36:51 +00:00
// NOTE: The FD flags are not shared between FileDescription objects.
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
// This means that dup() doesn't copy the FD_CLOEXEC flag!
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
switch (cmd) {
Add fcntl() F_DUPFD which is slightly different from dup2().
2018-11-16 21:14:40 +00:00
case F_DUPFD: {
int arg_fd = (int)arg;
if (arg_fd < 0)
return -EINVAL;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int new_fd = alloc_fd(arg_fd);
if (new_fd < 0)
return new_fd;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_fds[new_fd].set(*description);
Add fcntl() F_DUPFD which is slightly different from dup2().
2018-11-16 21:14:40 +00:00
break;
}
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
case F_GETFD:
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
return m_fds[fd].flags;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
case F_SETFD:
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
m_fds[fd].flags = arg;
break;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
case F_GETFL:
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->file_flags();
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
case F_SETFL:
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description->set_file_flags(arg);
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
break;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
default:
ASSERT_NOT_REACHED();
}
return 0;
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 09:38:33 +00:00
}
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$fstat(int fd, stat* statbuf)
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(statbuf))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->fstat(*statbuf);
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
}
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$lstat(const char* path, stat* statbuf)
Add an lstat() syscall and use it to make "ls" nicer.
2018-10-24 11:19:36 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(statbuf))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Generalize VFS metadata lookup and use it in mount() and stat() Refactored VFS::stat() into VFS::lookup_metadata(), which can now be used for general VFS metadata lookup by path.
2019-08-02 17:23:23 +00:00
auto metadata_or_error = VFS::the().lookup_metadata(StringView(path), current_directory(), O_NOFOLLOW_NOERROR);
if (metadata_or_error.is_error())
return metadata_or_error.error();
return metadata_or_error.value().stat(*statbuf);
Add an lstat() syscall and use it to make "ls" nicer.
2018-10-24 11:19:36 +00:00
}
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$stat(const char* path, stat* statbuf)
More LibC portability work while trying to get figlet building.
2018-10-31 09:14:56 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(statbuf))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Generalize VFS metadata lookup and use it in mount() and stat() Refactored VFS::stat() into VFS::lookup_metadata(), which can now be used for general VFS metadata lookup by path.
2019-08-02 17:23:23 +00:00
auto metadata_or_error = VFS::the().lookup_metadata(StringView(path), current_directory());
if (metadata_or_error.is_error())
return metadata_or_error.error();
return metadata_or_error.value().stat(*statbuf);
More LibC portability work while trying to get figlet building.
2018-10-31 09:14:56 +00:00
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
int Process::sys$readlink(const char* path, char* buffer, ssize_t size)
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(path))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
if (!validate_write(buffer, size))
return -EFAULT;
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
auto result = VFS::the().open(path, O_RDONLY | O_NOFOLLOW_NOERROR, 0, current_directory());
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
if (result.is_error())
return result.error();
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto description = result.value();
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->metadata().is_symlink())
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
return -EINVAL;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto contents = description->read_entire_file();
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
if (!contents)
return -EIO; // FIXME: Get a more detailed error from VFS.
ByteBuffer: Remove pointer() in favor of data() We had two ways to get the data inside a ByteBuffer. That was silly.
2019-09-30 06:57:01 +00:00
memcpy(buffer, contents.data(), min(size, (ssize_t)contents.size()));
Add basic symlink support. - sys$readlink + readlink() - Add a /proc/PID/exe symlink to the process's executable. - Print symlink contents in ls output. - Some work on plumbing options into VFS::open().
2018-10-28 13:11:51 +00:00
if (contents.size() + 1 < size)
buffer[contents.size()] = '\0';
return 0;
}
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
int Process::sys$chdir(const char* path)
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
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_str(path))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
auto directory_or_error = VFS::the().open_directory(StringView(path), current_directory());
Kernel: Support chdir() to a directory that's executable but not readable. Also the superuser should be allowed to resolve any possible path without getting tripped up by EACCES.
2019-03-01 22:54:07 +00:00
if (directory_or_error.is_error())
return directory_or_error.error();
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
m_cwd = *directory_or_error.value();
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
return 0;
}
Kernel: Implement fchdir syscall The fchdir() function is equivalent to chdir() except that the directory that is to be the new current working directory is specified by a file descriptor.
2019-09-11 23:18:25 +00:00
int Process::sys$fchdir(int fd)
{
auto* description = file_description(fd);
if (!description)
return -EBADF;
if (!description->is_directory())
ELF: Fail layout when program header hooks return nullptr (#673) ELFLoader::layout() had a "failed" variable that was never set. This patch checks the return value of each hook (alloc/map section and tls) and fails the load if they return null. I also needed to patch Process so that the alloc_section_hook and map_section_hook actually return nullptr when allocating a region fails. Fixes #664 :)
2019-10-20 14:24:42 +00:00
return -ENOTDIR;
Kernel: Implement fchdir syscall The fchdir() function is equivalent to chdir() except that the directory that is to be the new current working directory is specified by a file descriptor.
2019-09-11 23:18:25 +00:00
Kernel: fchdir() should fail for non-searchable directories So sayeth POSIX.
2019-09-13 12:35:18 +00:00
if (!description->metadata().may_execute(*this))
return -EACCES;
Kernel: Implement fchdir syscall The fchdir() function is equivalent to chdir() except that the directory that is to be the new current working directory is specified by a file descriptor.
2019-09-11 23:18:25 +00:00
m_cwd = description->custody();
return 0;
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
int Process::sys$getcwd(char* buffer, ssize_t size)
Implement sys$chdir() and teach sh+ls to cd around and browse different dirs.
2018-10-26 12:24:11 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
if (size < 0)
return -EINVAL;
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
if (!validate_write(buffer, size))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
auto path = current_directory().absolute_path();
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if ((size_t)size < path.length() + 1)
Implement sys$getcwd properly. Also fixed broken strcpy that didn't copy the null terminator.
2018-10-29 23:06:31 +00:00
return -ERANGE;
strcpy(buffer, path.characters());
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
return 0;
Implement sys$chdir() and teach sh+ls to cd around and browse different dirs.
2018-10-26 12:24:11 +00:00
}
Kernel: And some more KResult/KResultOr<T> porting work.
2019-03-06 21:30:13 +00:00
int Process::number_of_open_file_descriptors() const
Preallocate the maximum number of FileHandle pointers (fds) in every process. This could even use a more specific data structure since it doesn't need the grow/shrink capabilities of a vector.
2018-11-01 12:39:28 +00:00
{
Kernel: And some more KResult/KResultOr<T> porting work.
2019-03-06 21:30:13 +00:00
int count = 0;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
for (auto& description : m_fds) {
if (description)
Preallocate the maximum number of FileHandle pointers (fds) in every process. This could even use a more specific data structure since it doesn't need the grow/shrink capabilities of a vector.
2018-11-01 12:39:28 +00:00
++count;
}
return count;
}
Kernel: Have the open() syscall take an explicit path length parameter. Instead of computing the path length inside the syscall handler, let the caller do that work. This allows us to implement to new variants of open() and creat(), called open_with_path_length() and creat_with_path_length(). These are suitable for use with e.g StringView.
2019-07-08 18:01:49 +00:00
int Process::sys$open(const Syscall::SC_open_params* params)
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: Have the open() syscall take an explicit path length parameter. Instead of computing the path length inside the syscall handler, let the caller do that work. This allows us to implement to new variants of open() and creat(), called open_with_path_length() and creat_with_path_length(). These are suitable for use with e.g StringView.
2019-07-08 18:01:49 +00:00
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [path, path_length, options, mode] = *params;
Kernel: open() with a zero-length path should fail with EINVAL
2019-11-11 08:38:44 +00:00
if (!path_length)
return -EINVAL;
Kernel+LibC: Implement the openat() syscall POSIX's openat() is very similar to open(), except you also provide a file descriptor referring to a directory from which relative paths should be resolved. Passing it the magical fd number AT_FDCWD means "resolve from current directory" (which is indeed also what open() normally does.) This fixes libarchive's bsdtar, since it was trying to do something extremely wrong in the absence of openat() support. The issue has recently been fixed upstream in libarchive: https://github.com/libarchive/libarchive/issues/1239 However, we should have openat() support anyway, so I went ahead and implemented it. :^) Fixes #748.
2019-11-10 12:47:02 +00:00
if (!validate_read(path, path_length))
return -EFAULT;
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 08:33:37 +00:00
int fd = alloc_fd();
Lots of hacking: - Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
2018-10-23 08:12:50 +00:00
#ifdef DEBUG_IO
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 08:33:37 +00:00
dbgprintf("%s(%u) sys$open(\"%s\") -> %d\n", name().characters(), pid(), path, fd);
Lots of hacking: - Turn Keyboard into a CharacterDevice (85,1) at /dev/keyboard. - Implement MM::unmapRegionsForTask() and MM::unmapRegion() - Save SS correctly on interrupt. - Add a simple Spawn syscall for launching another process. - Move a bunch of IO syscall debug output behind DEBUG_IO. - Have ASSERT do a "cli" immediately when failing. This makes the output look proper every time. - Implement a bunch of syscalls in LibC. - Add a simple shell ("sh"). All it can do now is read a line of text from /dev/keyboard and then try launching the specified executable by calling spawn(). There are definitely bugs in here, but we're moving on forward.
2018-10-23 08:12:50 +00:00
#endif
Kernel+LibC: Implement the openat() syscall POSIX's openat() is very similar to open(), except you also provide a file descriptor referring to a directory from which relative paths should be resolved. Passing it the magical fd number AT_FDCWD means "resolve from current directory" (which is indeed also what open() normally does.) This fixes libarchive's bsdtar, since it was trying to do something extremely wrong in the absence of openat() support. The issue has recently been fixed upstream in libarchive: https://github.com/libarchive/libarchive/issues/1239 However, we should have openat() support anyway, so I went ahead and implemented it. :^) Fixes #748.
2019-11-10 12:47:02 +00:00
if (fd < 0)
return fd;
auto result = VFS::the().open(path, options, mode & ~umask(), current_directory());
if (result.is_error())
return result.error();
auto description = result.value();
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
description->set_rw_mode(options);
Kernel+LibC: Implement the openat() syscall POSIX's openat() is very similar to open(), except you also provide a file descriptor referring to a directory from which relative paths should be resolved. Passing it the magical fd number AT_FDCWD means "resolve from current directory" (which is indeed also what open() normally does.) This fixes libarchive's bsdtar, since it was trying to do something extremely wrong in the absence of openat() support. The issue has recently been fixed upstream in libarchive: https://github.com/libarchive/libarchive/issues/1239 However, we should have openat() support anyway, so I went ahead and implemented it. :^) Fixes #748.
2019-11-10 12:47:02 +00:00
description->set_file_flags(options);
u32 fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
m_fds[fd].set(move(description), fd_flags);
return fd;
}
int Process::sys$openat(const Syscall::SC_openat_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [dirfd, path, path_length, options, mode] = *params;
Kernel: Have the open() syscall take an explicit path length parameter. Instead of computing the path length inside the syscall handler, let the caller do that work. This allows us to implement to new variants of open() and creat(), called open_with_path_length() and creat_with_path_length(). These are suitable for use with e.g StringView.
2019-07-08 18:01:49 +00:00
if (!validate_read(path, path_length))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel+LibC: Implement the openat() syscall POSIX's openat() is very similar to open(), except you also provide a file descriptor referring to a directory from which relative paths should be resolved. Passing it the magical fd number AT_FDCWD means "resolve from current directory" (which is indeed also what open() normally does.) This fixes libarchive's bsdtar, since it was trying to do something extremely wrong in the absence of openat() support. The issue has recently been fixed upstream in libarchive: https://github.com/libarchive/libarchive/issues/1239 However, we should have openat() support anyway, so I went ahead and implemented it. :^) Fixes #748.
2019-11-10 12:47:02 +00:00
#ifdef DEBUG_IO
dbgprintf("%s(%u) sys$openat(%d, \"%s\")\n", dirfd, name().characters(), pid(), path);
#endif
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int fd = alloc_fd();
if (fd < 0)
return fd;
Kernel+LibC: Implement the openat() syscall POSIX's openat() is very similar to open(), except you also provide a file descriptor referring to a directory from which relative paths should be resolved. Passing it the magical fd number AT_FDCWD means "resolve from current directory" (which is indeed also what open() normally does.) This fixes libarchive's bsdtar, since it was trying to do something extremely wrong in the absence of openat() support. The issue has recently been fixed upstream in libarchive: https://github.com/libarchive/libarchive/issues/1239 However, we should have openat() support anyway, so I went ahead and implemented it. :^) Fixes #748.
2019-11-10 12:47:02 +00:00
RefPtr<Custody> base;
if (dirfd == AT_FDCWD) {
base = current_directory();
} else {
auto* base_description = file_description(dirfd);
if (!base_description)
return -EBADF;
if (!base_description->is_directory())
return -ENOTDIR;
if (!base_description->custody())
return -EINVAL;
base = base_description->custody();
}
auto result = VFS::the().open(path, options, mode & ~umask(), *base);
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
if (result.is_error())
return result.error();
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto description = result.value();
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
description->set_rw_mode(options);
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description->set_file_flags(options);
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 fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_fds[fd].set(move(description), fd_flags);
Add per-task limit for open fd's. Hard-coded at 16 for now.
2018-10-26 12:30:13 +00:00
return fd;
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: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int Process::alloc_fd(int first_candidate_fd)
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
{
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int fd = -EMFILE;
for (int i = first_candidate_fd; i < (int)m_max_open_file_descriptors; ++i) {
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
if (!m_fds[i]) {
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
fd = i;
break;
}
}
return fd;
}
Kernel+LibC: Support passing O_CLOEXEC to pipe() In the userspace, this mimics the Linux pipe2() syscall; in the kernel, the Process::sys$pipe() now always accepts a flags argument, the no-argument pipe() syscall is now a userspace wrapper over pipe2().
2019-08-05 12:29:05 +00:00
int Process::sys$pipe(int pipefd[2], int flags)
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(pipefd))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
if (number_of_open_file_descriptors() + 2 > max_open_file_descriptors())
return -EMFILE;
Kernel+LibC: Support passing O_CLOEXEC to pipe() In the userspace, this mimics the Linux pipe2() syscall; in the kernel, the Process::sys$pipe() now always accepts a flags argument, the no-argument pipe() syscall is now a userspace wrapper over pipe2().
2019-08-05 12:29:05 +00:00
// Reject flags other than O_CLOEXEC.
if ((flags & O_CLOEXEC) != flags)
return -EINVAL;
u32 fd_flags = (flags & O_CLOEXEC) ? FD_CLOEXEC : 0;
Kernel: Make it possible to look up FIFO's by ID. This will be useful when implementing the /proc/PID/fd/N links where N is a file descriptor referring to a FIFO.
2019-04-25 11:52:07 +00:00
auto fifo = FIFO::create(m_uid);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
int reader_fd = alloc_fd();
Kernel+LibC: Support passing O_CLOEXEC to pipe() In the userspace, this mimics the Linux pipe2() syscall; in the kernel, the Process::sys$pipe() now always accepts a flags argument, the no-argument pipe() syscall is now a userspace wrapper over pipe2().
2019-08-05 12:29:05 +00:00
m_fds[reader_fd].set(fifo->open_direction(FIFO::Direction::Reader), fd_flags);
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
m_fds[reader_fd].description->set_readable(true);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
pipefd[0] = reader_fd;
int writer_fd = alloc_fd();
Kernel+LibC: Support passing O_CLOEXEC to pipe() In the userspace, this mimics the Linux pipe2() syscall; in the kernel, the Process::sys$pipe() now always accepts a flags argument, the no-argument pipe() syscall is now a userspace wrapper over pipe2().
2019-08-05 12:29:05 +00:00
m_fds[writer_fd].set(fifo->open_direction(FIFO::Direction::Writer), fd_flags);
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
m_fds[writer_fd].description->set_writable(true);
Add primitive FIFO and hook it up to sys$pipe(). It's now possible to do this in bash: cat kernel.map | fgrep List This is very cool! :^)
2018-11-12 00:28:46 +00:00
pipefd[1] = writer_fd;
return 0;
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
}
int Process::sys$killpg(int pgrp, int signum)
{
if (signum < 1 || signum >= 32)
return -EINVAL;
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
if (pgrp < 0)
return -EINVAL;
InterruptDisabler disabler;
return do_killpg(pgrp, signum);
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
}
Kernel+Userland: Implement setuid() and setgid() and add /bin/su Also show setuid and setgid bits in "ls -l" output. :^)
2019-02-21 22:35:07 +00:00
int Process::sys$setuid(uid_t uid)
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
{
Kernel+Userland: Implement setuid() and setgid() and add /bin/su Also show setuid and setgid bits in "ls -l" output. :^)
2019-02-21 22:35:07 +00:00
if (uid != m_uid && !is_superuser())
return -EPERM;
m_uid = uid;
m_euid = uid;
return 0;
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
}
Kernel+Userland: Implement setuid() and setgid() and add /bin/su Also show setuid and setgid bits in "ls -l" output. :^)
2019-02-21 22:35:07 +00:00
int Process::sys$setgid(gid_t gid)
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
{
Kernel+Userland: Implement setuid() and setgid() and add /bin/su Also show setuid and setgid bits in "ls -l" output. :^)
2019-02-21 22:35:07 +00:00
if (gid != m_gid && !is_superuser())
return -EPERM;
m_gid = gid;
m_egid = gid;
return 0;
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +00:00
}
unsigned Process::sys$alarm(unsigned seconds)
{
Kernel: Implement the alarm() syscall.
2019-06-07 09:30:07 +00:00
unsigned previous_alarm_remaining = 0;
if (m_alarm_deadline && m_alarm_deadline > g_uptime) {
previous_alarm_remaining = (m_alarm_deadline - g_uptime) / TICKS_PER_SECOND;
}
if (!seconds) {
m_alarm_deadline = 0;
return previous_alarm_remaining;
}
m_alarm_deadline = g_uptime + seconds * TICKS_PER_SECOND;
return previous_alarm_remaining;
A bunch of compat work (mostly stubs but some real implementations, too.) Another pass at getting bash-1.14.7 to build. Not that many symbols remain.
2018-11-10 23:20:53 +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
int Process::sys$uname(utsname* buf)
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(buf))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Embrace the SerenityOS name
2019-12-29 18:08:02 +00:00
strcpy(buf->sysname, "SerenityOS");
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +00:00
strcpy(buf->release, "1.0-dev");
strcpy(buf->version, "FIXME");
Kernel: Let's have sys$uname() report "i686" instead of "i386" We wouldn't be able to run on an 80386 without considerable changes, so let's be honest here and call it i686.
2019-11-17 18:39:12 +00:00
strcpy(buf->machine, "i686");
Kernel: Don't disable interrupts to access the system hostname.
2019-02-07 09:29:26 +00:00
LOCKER(*s_hostname_lock);
strncpy(buf->nodename, s_hostname->characters(), sizeof(utsname::nodename));
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +00:00
return 0;
}
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
KResult Process::do_kill(Process& process, int signal)
{
// FIXME: Allow sending SIGCONT to everyone in the process group.
// FIXME: Should setuid processes have some special treatment here?
if (!is_superuser() && m_euid != process.m_uid && m_uid != process.m_uid)
return KResult(-EPERM);
if (process.is_ring0() && signal == SIGKILL) {
kprintf("%s(%u) attempted to send SIGKILL to ring 0 process %s(%u)\n", name().characters(), m_pid, process.name().characters(), process.pid());
return KResult(-EPERM);
}
Kernel: kill() with signal 0 should not actually send anything Also kill() with pid 0 should send to everyone in the same process group as the calling process.
2020-01-03 01:01:45 +00:00
if (signal != 0)
process.send_signal(signal, this);
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
return KSuccess;
}
KResult Process::do_killpg(pid_t pgrp, int signal)
{
ASSERT(pgrp >= 0);
// Send the signal to all processes in the given group.
if (pgrp == 0) {
// Send the signal to our own pgrp.
pgrp = pgid();
}
bool group_was_empty = true;
bool any_succeeded = false;
KResult error = KSuccess;
Process::for_each_in_pgrp(pgrp, [&](auto& process) {
group_was_empty = false;
KResult res = do_kill(process, signal);
if (res.is_success())
any_succeeded = true;
else
error = res;
return IterationDecision::Continue;
});
if (group_was_empty)
return KResult(-ESRCH);
if (any_succeeded)
return KSuccess;
return error;
}
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
int Process::sys$kill(pid_t pid, int signal)
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: Only allow sending signals to process you own.
2019-02-28 10:45:45 +00:00
if (signal < 0 || signal >= 32)
return -EINVAL;
Kernel: Remove unnecessary logic in kill() and killpg() syscalls As Sergey pointed out, do_killpg() already interprets PID 0 as the PGID of the calling process.
2020-01-03 11:58:59 +00:00
if (pid <= 0)
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
return do_killpg(-pid, signal);
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
if (pid == -1) {
// FIXME: Send to all processes.
Kernel: kill() with signal 0 should not actually send anything Also kill() with pid 0 should send to everyone in the same process group as the calling process.
2020-01-03 01:01:45 +00:00
return -ENOTIMPL;
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: kill() syscall should support sending a signal to yourself.
2019-02-28 08:44:48 +00:00
if (pid == m_pid) {
Kernel: kill() with signal 0 should not actually send anything Also kill() with pid 0 should send to everyone in the same process group as the calling process.
2020-01-03 01:01:45 +00:00
if (signal == 0)
return 0;
if (!current->should_ignore_signal(signal)) {
current->send_signal(signal, this);
(void)current->block<Thread::SemiPermanentBlocker>(Thread::SemiPermanentBlocker::Reason::Signal);
}
Kernel: kill() syscall should support sending a signal to yourself.
2019-02-28 08:44:48 +00:00
return 0;
}
Kernel: Only allow sending signals to process you own.
2019-02-28 10:45:45 +00:00
InterruptDisabler disabler;
auto* peer = Process::from_pid(pid);
Implement basic sys$kill() and add a /bin/kill All it can do right now is send SIGKILL which just murders the target task.
2018-10-31 00:06:57 +00:00
if (!peer)
return -ESRCH;
Kernel: Implement the killpg() syscall
2019-11-14 16:16:30 +00:00
return do_kill(*peer, signal);
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
}
Get nyancat nyanning in Serenity. I found a cute program that renders an animated nyancat in the terminal. This patch adds enough hackery to get it working correctly. :^)
2019-02-03 15:11:28 +00:00
int Process::sys$usleep(useconds_t usec)
{
if (!usec)
return 0;
Kernel: Port sleep to ThreadBlocker
2019-07-18 15:26:11 +00:00
u64 wakeup_time = current->sleep(usec / 1000);
Kernel: If a process is interrupted during usleep(), return -EINTR
2019-11-06 20:01:44 +00:00
if (wakeup_time > g_uptime)
return -EINTR;
Get nyancat nyanning in Serenity. I found a cute program that renders an animated nyancat in the terminal. This patch adds enough hackery to get it working correctly. :^)
2019-02-03 15:11:28 +00:00
return 0;
}
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
int Process::sys$sleep(unsigned seconds)
Add a "sleep" syscall that sleeps for N seconds.
2018-10-25 11:53:49 +00:00
{
if (!seconds)
return 0;
Kernel: Port sleep to ThreadBlocker
2019-07-18 15:26:11 +00:00
u64 wakeup_time = current->sleep(seconds * TICKS_PER_SECOND);
if (wakeup_time > g_uptime) {
u32 ticks_left_until_original_wakeup_time = wakeup_time - g_uptime;
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
return ticks_left_until_original_wakeup_time / TICKS_PER_SECOND;
}
Add a "sleep" syscall that sleeps for N seconds.
2018-10-25 11:53:49 +00:00
return 0;
}
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
timeval 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: Make sure the kernel info page is read-only for userspace To enforce this, we create two separate mappings of the same underlying physical page. A writable mapping for the kernel, and a read-only one for userspace (the one returned by sys$get_kernel_info_page.)
2019-12-15 21:21:28 +00:00
return const_cast<const timeval&>(((KernelInfoPage*)s_info_page_address_for_kernel.as_ptr())->now);
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
}
void kgettimeofday(timeval& tv)
{
tv = 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
}
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
int Process::sys$gettimeofday(timeval* tv)
Add gettimeofday() syscall and LibC wrappers gettimeofday() and time(). This only has second accuracy right now, I'll work out subseconds later.
2018-10-25 15:29:49 +00:00
{
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(tv))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
*tv = kgettimeofday();
Add gettimeofday() syscall and LibC wrappers gettimeofday() and time(). This only has second accuracy right now, I'll work out subseconds later.
2018-10-25 15:29:49 +00:00
return 0;
}
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
uid_t Process::sys$getuid()
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
{
return m_uid;
}
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
gid_t Process::sys$getgid()
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 11:55:11 +00:00
{
return m_gid;
}
Add geteuid() and getegid(). There's no support for set-uid or set-gid executables yet so these don't actually do anything. It's just nice to get the boilerplate stuff in.
2018-11-05 14:04:19 +00:00
uid_t Process::sys$geteuid()
{
return m_euid;
}
gid_t Process::sys$getegid()
{
return m_egid;
}
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
pid_t Process::sys$getpid()
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 11:55:11 +00:00
{
return m_pid;
}
Add getppid().
2018-11-06 12:33:06 +00:00
pid_t Process::sys$getppid()
{
return m_ppid;
}
Add umask().
2018-11-06 12:40:23 +00:00
mode_t Process::sys$umask(mode_t mask)
{
auto old_mask = m_umask;
Kernel: Respect the process umask in open() and mkdir().
2019-02-22 01:39:13 +00:00
m_umask = mask & 0777;
Add umask().
2018-11-06 12:40:23 +00:00
return old_mask;
}
Let reap() communicate the dead process's exit status to the caller. This way the scheduler doesn't need to plumb the exit status into the waiter. We still plumb the waitee pid though, I don't love it but it can be fixed.
2018-11-28 21:01:24 +00:00
int Process::reap(Process& process)
Get rid of the undertaker and have waitpid() be the reaper. For dead orphans, the scheduler calls reap().
2018-11-07 22:59:49 +00:00
{
Kernel: Don't disable interrupts during Process destruction.
2019-03-27 13:38:32 +00:00
int exit_status;
{
InterruptDisabler disabler;
exit_status = (process.m_termination_status << 8) | process.m_termination_signal;
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: Don't disable interrupts during Process destruction.
2019-03-27 13:38:32 +00:00
if (process.ppid()) {
auto* parent = Process::from_pid(process.ppid());
if (parent) {
parent->m_ticks_in_user_for_dead_children += process.m_ticks_in_user + process.m_ticks_in_user_for_dead_children;
parent->m_ticks_in_kernel_for_dead_children += process.m_ticks_in_kernel + process.m_ticks_in_kernel_for_dead_children;
}
Destroy all remaining windows in a process when it dies.
2019-01-30 18:35:38 +00:00
}
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: 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
dbgprintf("reap: %s(%u)\n", process.name().characters(), process.pid());
Kernel: Don't disable interrupts during Process destruction.
2019-03-27 13:38:32 +00:00
ASSERT(process.is_dead());
g_processes->remove(&process);
}
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
delete &process;
Let reap() communicate the dead process's exit status to the caller. This way the scheduler doesn't need to plumb the exit status into the waiter. We still plumb the waitee pid though, I don't love it but it can be fixed.
2018-11-28 21:01:24 +00:00
return exit_status;
Get rid of the undertaker and have waitpid() be the reaper. For dead orphans, the scheduler calls reap().
2018-11-07 22:59:49 +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
pid_t Process::sys$waitpid(pid_t waitee, int* wstatus, int options)
Add a simplified waitpid() so that sh can wait on spawned commands.
2018-10-23 22:20:34 +00:00
{
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
dbgprintf("sys$waitpid(%d, %p, %d)\n", waitee, wstatus, options);
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
if (!options) {
// FIXME: This can't be right.. can it? Figure out how this should actually work.
options = WEXITED;
}
Implement waitpid() support for getting the waitee's exit code.
2018-10-26 23:24:22 +00:00
if (wstatus)
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(wstatus))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Implement waitpid() support for getting the waitee's exit code.
2018-10-26 23:24:22 +00:00
Let reap() communicate the dead process's exit status to the caller. This way the scheduler doesn't need to plumb the exit status into the waiter. We still plumb the waitee pid though, I don't love it but it can be fixed.
2018-11-28 21:01:24 +00:00
int dummy_wstatus;
int& exit_status = wstatus ? *wstatus : dummy_wstatus;
Get rid of the undertaker and have waitpid() be the reaper. For dead orphans, the scheduler calls reap().
2018-11-07 22:59:49 +00:00
{
InterruptDisabler disabler;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
if (waitee != -1 && !Process::from_pid(waitee))
Get rid of the undertaker and have waitpid() be the reaper. For dead orphans, the scheduler calls reap().
2018-11-07 22:59:49 +00:00
return -ECHILD;
}
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
if (options & WNOHANG) {
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
// FIXME: Figure out what WNOHANG should do with stopped children.
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
if (waitee == -1) {
pid_t reaped_pid = 0;
InterruptDisabler disabler;
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
for_each_child([&reaped_pid, &exit_status](Process& process) {
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
if (process.is_dead()) {
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
reaped_pid = process.pid();
Let reap() communicate the dead process's exit status to the caller. This way the scheduler doesn't need to plumb the exit status into the waiter. We still plumb the waitee pid though, I don't love it but it can be fixed.
2018-11-28 21:01:24 +00:00
exit_status = reap(process);
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
}
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
return IterationDecision::Continue;
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
});
return reaped_pid;
} else {
Kernel: Ignore SIGCHLD by default. Also use an enum for the rather-confusing return value in dispatch_signal(). I will go through the rest of the signals and set them up with the appropriate default dispositions at some other point.
2019-02-04 13:06:38 +00:00
ASSERT(waitee > 0); // FIXME: Implement other PID specs.
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
InterruptDisabler disabler;
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
auto* waitee_process = Process::from_pid(waitee);
if (!waitee_process)
return -ECHILD;
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
if (waitee_process->is_dead()) {
Let reap() communicate the dead process's exit status to the caller. This way the scheduler doesn't need to plumb the exit status into the waiter. We still plumb the waitee pid though, I don't love it but it can be fixed.
2018-11-28 21:01:24 +00:00
exit_status = reap(*waitee_process);
Make bash-2.05b build with minimal changes. This is really neat. :^)
2018-11-16 23:11:08 +00:00
return waitee;
}
return 0;
}
}
Kernel: Port wait to ThreadBlocker
2019-07-18 16:05:19 +00:00
pid_t waitee_pid = waitee;
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
if (current->block<Thread::WaitBlocker>(options, waitee_pid) == Thread::BlockResult::InterruptedBySignal)
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
return -EINTR;
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
InterruptDisabler disabler;
// NOTE: If waitee was -1, m_waitee_pid will have been filled in by the scheduler.
Kernel: Port wait to ThreadBlocker
2019-07-18 16:05:19 +00:00
Process* waitee_process = Process::from_pid(waitee_pid);
Kernel: waitpid() should unblock and -ECHILD if SIG_IGN reaps child
2019-09-08 11:54:48 +00:00
if (!waitee_process)
return -ECHILD;
Fix some paging related bugs exposed by the spawn stress test. - Process::exec() needs to restore the original paging scope when called on a non-current process. - Add missing InterruptDisabler guards around g_processes access. - Only flush the TLB when modifying the active page tables.
2018-11-09 00:25:31 +00:00
ASSERT(waitee_process);
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
if (waitee_process->is_dead()) {
exit_status = reap(*waitee_process);
} else {
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
ASSERT(waitee_process->any_thread().state() == Thread::State::Stopped);
Kernel: Add support for the WSTOPPED flag to the waitpid() syscall. This makes waitpid() return when a child process is stopped via a signal. Use this in Shell to catch stopped children and return control to the command line. :^) Fixes #298.
2019-07-14 09:35:49 +00:00
exit_status = 0x7f;
}
Kernel: Port wait to ThreadBlocker
2019-07-18 16:05:19 +00:00
return waitee_pid;
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 i386.{cpp,h} => Arch/i386/CPU.{cpp,h} There's a ton of work that would need to be done before we could spin up on another architecture, but let's at least try to separate things out a bit.
2019-06-07 18:02:01 +00:00
enum class KernelMemoryCheckResult {
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
NotInsideKernelMemory,
AccessGranted,
AccessDenied
};
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
static KernelMemoryCheckResult check_kernel_memory_access(VirtualAddress vaddr, bool is_write)
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
{
Kernel: Make better use of the multiboot info. Define the multiboot info struct properly so we don't have to grab at byte offsets in the memory access checker code. Also print kernel command line in init().
2019-06-02 07:50:18 +00:00
auto& sections = multiboot_info_ptr->u.elf_sec;
Kernel: Pass ELF program header locations from multiboot to kernel. Patch contributed by "pd"
2019-05-18 01:06:34 +00:00
Kernel: Make better use of the multiboot info. Define the multiboot info struct properly so we don't have to grab at byte offsets in the memory access checker code. Also print kernel command line in init().
2019-06-02 07:50:18 +00:00
auto* kernel_program_headers = (Elf32_Phdr*)(sections.addr);
for (unsigned i = 0; i < sections.num; ++i) {
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
auto& segment = kernel_program_headers[i];
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
if (segment.p_type != PT_LOAD || !segment.p_vaddr || !segment.p_memsz)
continue;
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
if (vaddr.get() < segment.p_vaddr || vaddr.get() > (segment.p_vaddr + segment.p_memsz))
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
continue;
if (is_write && !(kernel_program_headers[i].p_flags & PF_W))
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
return KernelMemoryCheckResult::AccessDenied;
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
if (!is_write && !(kernel_program_headers[i].p_flags & PF_R))
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
return KernelMemoryCheckResult::AccessDenied;
return KernelMemoryCheckResult::AccessGranted;
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
}
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
return KernelMemoryCheckResult::NotInsideKernelMemory;
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
}
Kernel: Add a size argument to validate_read_from_kernel
2019-12-24 00:01:23 +00:00
bool Process::validate_read_from_kernel(VirtualAddress vaddr, ssize_t size) const
Greatly improve /proc/PID/stack by tracing the ebp frame chain. I also added a generator cache to FileHandle. This way, multiple reads to a generated file (i.e in a synthfs) can transparently handle multiple calls to read() without the contents changing between calls. The cache is discarded at EOF (or when the FileHandle is destroyed.)
2018-10-26 22:14:24 +00:00
{
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
if (vaddr.is_null())
Kernel: Make validate_read_from_kernel() return early for nullptr checks. Null pointers are always invalid, so don't bother going through all the various checks for them.
2019-04-15 21:48:31 +00:00
return false;
Implement address validation by querying the task's page directory. This is way better than walking the region lists. I suppose we could even let the hardware trigger a page fault and handle that. That'll be the next step in the evolution here I guess.
2018-11-01 11:45:51 +00:00
// We check extra carefully here since the first 4MB of the address space is identity-mapped.
// This code allows access outside of the known used address ranges to get caught.
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
auto kmc_result = check_kernel_memory_access(vaddr, false);
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
if (kmc_result == KernelMemoryCheckResult::AccessGranted)
Greatly improve /proc/PID/stack by tracing the ebp frame chain. I also added a generator cache to FileHandle. This way, multiple reads to a generated file (i.e in a synthfs) can transparently handle multiple calls to read() without the contents changing between calls. The cache is discarded at EOF (or when the FileHandle is destroyed.)
2018-10-26 22:14:24 +00:00
return true;
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
if (kmc_result == KernelMemoryCheckResult::AccessDenied)
return false;
Kernel: Rename LinearAddress => VirtualAddress.
2019-06-07 10:56:50 +00:00
if (is_kmalloc_address(vaddr.as_ptr()))
Greatly improve /proc/PID/stack by tracing the ebp frame chain. I also added a generator cache to FileHandle. This way, multiple reads to a generated file (i.e in a synthfs) can transparently handle multiple calls to read() without the contents changing between calls. The cache is discarded at EOF (or when the FileHandle is destroyed.)
2018-10-26 22:14:24 +00:00
return true;
Kernel: Validate the full range of user memory passed to syscalls We now validate the full range of userspace memory passed into syscalls instead of just checking that the first and last byte of the memory are in process-owned regions. This fixes an issue where it was possible to avoid rejection of invalid addresses that sat between two valid ones, simply by passing a valid address and a size large enough to put the end of the range at another valid address. I added a little test utility that tries to provoke EFAULT in various ways to help verify this. I'm sure we can think of more ways to test this but it's at least a start. :^) Thanks to mozjag for pointing out that this code was still lacking! Incidentally this also makes backtraces work again. Fixes #989.
2020-01-02 01:09:25 +00:00
return MM.validate_kernel_read(*this, vaddr, size);
Greatly improve /proc/PID/stack by tracing the ebp frame chain. I also added a generator cache to FileHandle. This way, multiple reads to a generated file (i.e in a synthfs) can transparently handle multiple calls to read() without the contents changing between calls. The cache is discarded at EOF (or when the FileHandle is destroyed.)
2018-10-26 22:14:24 +00:00
}
Kernel: When validating a string read, validate the pointer first. Calling strlen() on an invalid pointer is just gonna crash the process.
2019-02-07 23:10:01 +00:00
bool Process::validate_read_str(const char* str)
{
if (!validate_read(str, 1))
return false;
return validate_read(str, strlen(str) + 1);
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
bool Process::validate_read(const void* address, ssize_t size) const
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
ASSERT(size >= 0);
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
VirtualAddress first_address((u32)address);
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
if (is_ring0()) {
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
auto kmc_result = check_kernel_memory_access(first_address, false);
if (kmc_result == KernelMemoryCheckResult::AccessGranted)
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
return true;
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
if (kmc_result == KernelMemoryCheckResult::AccessDenied)
return false;
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
if (is_kmalloc_address(address))
return true;
}
Kernel: Fix incorrect EFAULTs when syscall would write into COW pages.
2019-01-25 00:39:15 +00:00
if (!size)
return false;
Kernel: Validate the full range of user memory passed to syscalls We now validate the full range of userspace memory passed into syscalls instead of just checking that the first and last byte of the memory are in process-owned regions. This fixes an issue where it was possible to avoid rejection of invalid addresses that sat between two valid ones, simply by passing a valid address and a size large enough to put the end of the range at another valid address. I added a little test utility that tries to provoke EFAULT in various ways to help verify this. I'm sure we can think of more ways to test this but it's at least a start. :^) Thanks to mozjag for pointing out that this code was still lacking! Incidentally this also makes backtraces work again. Fixes #989.
2020-01-02 01:09:25 +00:00
return MM.validate_user_read(*this, first_address, size);
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
}
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
bool Process::validate_write(void* address, ssize_t size) const
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
{
Kernel: Make syscalls that take a buffer size use ssize_t instead of size_t. Dealing with the unsigned overflow propagation here just seems unreasonably error prone. Let's limit ourselves to 2GB buffer sizes instead.
2019-02-25 20:19:57 +00:00
ASSERT(size >= 0);
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
VirtualAddress first_address((u32)address);
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
if (is_ring0()) {
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
if (is_kmalloc_address(address))
return true;
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
auto kmc_result = check_kernel_memory_access(first_address, true);
if (kmc_result == KernelMemoryCheckResult::AccessGranted)
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +00:00
return true;
Kernel: Oops, the kernel image access validator thought 0x0 was allowed. We forgot to look at the ELF segment type when validating accesses. We should only consider accesses inside non-empty LOAD segments.
2019-02-11 05:03:30 +00:00
if (kmc_result == KernelMemoryCheckResult::AccessDenied)
return false;
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
}
Kernel: Fix incorrect EFAULTs when syscall would write into COW pages.
2019-01-25 00:39:15 +00:00
if (!size)
return false;
Kernel: Validate the full range of user memory passed to syscalls We now validate the full range of userspace memory passed into syscalls instead of just checking that the first and last byte of the memory are in process-owned regions. This fixes an issue where it was possible to avoid rejection of invalid addresses that sat between two valid ones, simply by passing a valid address and a size large enough to put the end of the range at another valid address. I added a little test utility that tries to provoke EFAULT in various ways to help verify this. I'm sure we can think of more ways to test this but it's at least a start. :^) Thanks to mozjag for pointing out that this code was still lacking! Incidentally this also makes backtraces work again. Fixes #989.
2020-01-02 01:09:25 +00:00
return MM.validate_user_write(*this, first_address, size);
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
}
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
pid_t Process::sys$getsid(pid_t pid)
{
if (pid == 0)
return m_sid;
InterruptDisabler disabler;
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
auto* process = Process::from_pid(pid);
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
if (!process)
return -ESRCH;
if (m_sid != process->m_sid)
return -EPERM;
return process->m_sid;
}
pid_t Process::sys$setsid()
{
InterruptDisabler disabler;
bool found_process_with_same_pgid_as_my_pid = false;
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
Process::for_each_in_pgrp(pid(), [&](auto&) {
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
found_process_with_same_pgid_as_my_pid = true;
Kernel: Use IteratorDecision in Process::for_each_in_pgrp()
2019-08-22 19:12:55 +00:00
return IterationDecision::Break;
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
});
if (found_process_with_same_pgid_as_my_pid)
return -EPERM;
m_sid = m_pid;
m_pgid = m_pid;
return m_sid;
}
pid_t Process::sys$getpgid(pid_t pid)
{
if (pid == 0)
return m_pgid;
InterruptDisabler disabler; // FIXME: Use a ProcessHandle
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
auto* process = Process::from_pid(pid);
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
if (!process)
return -ESRCH;
return process->m_pgid;
}
pid_t Process::sys$getpgrp()
{
return m_pgid;
}
static pid_t get_sid_from_pgid(pid_t pgid)
{
InterruptDisabler disabler;
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
auto* group_leader = Process::from_pid(pgid);
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
if (!group_leader)
return -1;
return group_leader->sid();
}
int Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
{
InterruptDisabler disabler; // FIXME: Use a ProcessHandle
pid_t pid = specified_pid ? specified_pid : m_pid;
Kernel: Add some missing error checks to the setpgid() syscall
2020-01-02 18:40:04 +00:00
if (specified_pgid < 0) {
// The value of the pgid argument is less than 0, or is not a value supported by the implementation.
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
return -EINVAL;
Kernel: Add some missing error checks to the setpgid() syscall
2020-01-02 18:40:04 +00:00
}
Some refactor and style tweaks.
2018-11-07 20:38:18 +00:00
auto* process = Process::from_pid(pid);
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
if (!process)
return -ESRCH;
Kernel: Add some missing error checks to the setpgid() syscall
2020-01-02 18:40:04 +00:00
if (process != this && process->ppid() != m_pid) {
// The value of the pid argument does not match the process ID
// of the calling process or of a child process of the calling process.
return -ESRCH;
}
if (process->pid() == process->sid()) {
// The process indicated by the pid argument is a session leader.
return -EPERM;
}
if (process->ppid() == m_pid && process->sid() != sid()) {
// The value of the pid argument matches the process ID of a child
// process of the calling process and the child process is not in
// the same session as the calling process.
return -EPERM;
}
Start working on sessions and process groups.
2018-11-02 11:56:51 +00:00
pid_t new_pgid = specified_pgid ? specified_pgid : process->m_pid;
pid_t current_sid = get_sid_from_pgid(process->m_pgid);
pid_t new_sid = get_sid_from_pgid(new_pgid);
if (current_sid != new_sid) {
// Can't move a process between sessions.
return -EPERM;
}
// FIXME: There are more EPERM conditions to check for here..
process->m_pgid = new_pgid;
return 0;
}
Add tcsetpgrp()+tcgetpgrp(). One more step on the path to being able to ^C a runaway process. :^)
2018-11-02 12:14:25 +00:00
Add ioctl() and reimplement tcsetpgrp/tcsetpgrp as ioctls.
2018-11-16 12:11:21 +00:00
int Process::sys$ioctl(int fd, unsigned request, unsigned arg)
Add tcsetpgrp()+tcgetpgrp(). One more step on the path to being able to ^C a runaway process. :^)
2018-11-02 12:14:25 +00:00
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Add tcsetpgrp()+tcgetpgrp(). One more step on the path to being able to ^C a runaway process. :^)
2018-11-02 12:14:25 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->file().ioctl(*description, request, arg);
Add tcsetpgrp()+tcgetpgrp(). One more step on the path to being able to ^C a runaway process. :^)
2018-11-02 12:14:25 +00:00
}
More work towards getting bash to build. Implemented some syscalls: dup(), dup2(), getdtablesize(). FileHandle is now a retainable, since that's needed for dup()'ed fd's. I didn't really test any of this beyond a basic smoke check.
2018-11-05 18:01:22 +00:00
int Process::sys$getdtablesize()
{
return m_max_open_file_descriptors;
}
int Process::sys$dup(int old_fd)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(old_fd);
if (!description)
More work towards getting bash to build. Implemented some syscalls: dup(), dup2(), getdtablesize(). FileHandle is now a retainable, since that's needed for dup()'ed fd's. I didn't really test any of this beyond a basic smoke check.
2018-11-05 18:01:22 +00:00
return -EBADF;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int new_fd = alloc_fd(0);
if (new_fd < 0)
return new_fd;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_fds[new_fd].set(*description);
More work towards getting bash to build. Implemented some syscalls: dup(), dup2(), getdtablesize(). FileHandle is now a retainable, since that's needed for dup()'ed fd's. I didn't really test any of this beyond a basic smoke check.
2018-11-05 18:01:22 +00:00
return new_fd;
}
int Process::sys$dup2(int old_fd, int new_fd)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(old_fd);
if (!description)
More work towards getting bash to build. Implemented some syscalls: dup(), dup2(), getdtablesize(). FileHandle is now a retainable, since that's needed for dup()'ed fd's. I didn't really test any of this beyond a basic smoke check.
2018-11-05 18:01:22 +00:00
return -EBADF;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
if (new_fd < 0 || new_fd >= m_max_open_file_descriptors)
return -EINVAL;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_fds[new_fd].set(*description);
More work towards getting bash to build. Implemented some syscalls: dup(), dup2(), getdtablesize(). FileHandle is now a retainable, since that's needed for dup()'ed fd's. I didn't really test any of this beyond a basic smoke check.
2018-11-05 18:01:22 +00:00
return new_fd;
}
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +00:00
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$sigprocmask(int how, const sigset_t* set, sigset_t* old_set)
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
{
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
if (old_set) {
Kernel: sigpending() and sigprocmask() should validate memory writes.
2019-02-21 20:33:52 +00:00
if (!validate_write_typed(old_set))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
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
*old_set = current->m_signal_mask;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
}
if (set) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_typed(set))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
switch (how) {
case SIG_BLOCK:
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
current->m_signal_mask &= ~(*set);
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
break;
case SIG_UNBLOCK:
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
current->m_signal_mask |= *set;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
break;
case SIG_SETMASK:
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
current->m_signal_mask = *set;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
break;
default:
return -EINVAL;
}
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
}
return 0;
}
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$sigpending(sigset_t* set)
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
{
Kernel: sigpending() and sigprocmask() should validate memory writes.
2019-02-21 20:33:52 +00:00
if (!validate_write_typed(set))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
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
*set = current->m_pending_signals;
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-10 22:29:07 +00:00
return 0;
}
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +00:00
{
Let sys$sigaction() fail if called with SIGKILL or SIGSTOP.
2018-12-24 21:22:19 +00:00
if (signum < 1 || signum >= 32 || signum == SIGKILL || signum == SIGSTOP)
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +00:00
return -EINVAL;
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read_typed(act))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Kernel: Remove a bunch of unnecessary InterruptDisablers.
2019-02-07 10:24:09 +00:00
InterruptDisabler disabler; // FIXME: This should use a narrower lock. Maybe a way to ignore signals temporarily?
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
auto& action = current->m_signal_action_data[signum];
Fix sys$sigaction() to return the old action metadata if requested.
2018-11-07 09:48:44 +00:00
if (old_act) {
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(old_act))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
Fix sys$sigaction() to return the old action metadata if requested.
2018-11-07 09:48:44 +00:00
old_act->sa_flags = action.flags;
old_act->sa_sigaction = (decltype(old_act->sa_sigaction))action.handler_or_sigaction.get();
}
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +00:00
action.flags = act->sa_flags;
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
action.handler_or_sigaction = VirtualAddress((u32)act->sa_sigaction);
Add some basic signal support. It only works for sending a signal to a process that's in userspace code. We implement reception by synthesizing a PUSHA+PUSHF in the receiving process (operating on values in the TSS.) The TSS CS:EIP is then rerouted to the signal handler and a tiny return trampoline is constructed in a dedicated region in the receiving process. Also hacked up /bin/kill to be able to send arbitrary signals (kill -N PID)
2018-11-06 09:46:40 +00:00
return 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
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
int Process::sys$getgroups(ssize_t count, gid_t* gids)
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
{
if (count < 0)
return -EINVAL;
if (!count)
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 m_extra_gids.size();
if (count != (int)m_extra_gids.size())
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
return -EINVAL;
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
if (!validate_write_typed(gids, m_extra_gids.size()))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
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
size_t i = 0;
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
for (auto gid : m_extra_gids)
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
gids[i++] = gid;
return 0;
}
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
int Process::sys$setgroups(ssize_t count, const gid_t* gids)
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
{
More moving towards using signed types. I'm still feeling this out, but I am starting to like the general idea.
2019-02-25 21:06:55 +00:00
if (count < 0)
return -EINVAL;
Kernel+Userland: Implement setuid() and setgid() and add /bin/su Also show setuid and setgid bits in "ls -l" output. :^)
2019-02-21 22:35:07 +00:00
if (!is_superuser())
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
return -EPERM;
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_read(gids, count))
Improve syscall address validation a bit.
2018-11-16 15:10:59 +00:00
return -EFAULT;
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
m_extra_gids.clear();
for (int i = 0; i < count; ++i) {
if (gids[i] == m_gid)
continue;
m_extra_gids.set(gids[i]);
}
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
return 0;
}
Finally hook up the mkdir code to a syscall. Added a /bin/mkdir that makes directories. How very neat :^) There are various limitations because of missing functionality.
2018-11-18 13:57:41 +00:00
int Process::sys$mkdir(const char* pathname, mode_t mode)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: mkdir() should fail if the pathname is empty.
2019-02-01 14:24:42 +00:00
size_t pathname_length = strlen(pathname);
if (pathname_length == 0)
return -EINVAL;
if (pathname_length >= 255)
Finally hook up the mkdir code to a syscall. Added a /bin/mkdir that makes directories. How very neat :^) There are various limitations because of missing functionality.
2018-11-18 13:57:41 +00:00
return -ENAMETOOLONG;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().mkdir(StringView(pathname, pathname_length), mode & ~umask(), current_directory());
Finally hook up the mkdir code to a syscall. Added a /bin/mkdir that makes directories. How very neat :^) There are various limitations because of missing functionality.
2018-11-18 13:57:41 +00:00
}
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: Add realpath syscall
2019-08-25 16:17:05 +00:00
int Process::sys$realpath(const char* pathname, char* buffer, size_t size)
{
if (!validate_read_str(pathname))
return -EFAULT;
size_t pathname_length = strlen(pathname);
if (pathname_length == 0)
return -EINVAL;
if (pathname_length >= size)
return -ENAMETOOLONG;
if (!validate_write(buffer, size))
return -EFAULT;
auto custody_or_error = VFS::the().resolve_path(pathname, current_directory());
if (custody_or_error.is_error())
return custody_or_error.error();
auto& custody = custody_or_error.value();
// FIXME: Once resolve_path is fixed to deal with .. and . , remove the use of FileSystemPath::canonical_path.
FileSystemPath canonical_path(custody->absolute_path());
if (!canonical_path.is_valid()) {
Kernel: Fix broken passing of String as printf() argument in realpath()
2019-08-29 19:01:33 +00:00
dbg() << "FileSystemPath failed to canonicalize " << custody->absolute_path();
ASSERT_NOT_REACHED();
Kernel: Add realpath syscall
2019-08-25 16:17:05 +00:00
}
strncpy(buffer, canonical_path.string().characters(), size);
return 0;
};
Kernel: Get rid of Unix namespace. This is no longer needed as the Kernel can stand on its own legs now and there won't be any conflict with host system data types.
2019-01-23 05:53:01 +00:00
clock_t Process::sys$times(tms* times)
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
{
if (!validate_write_typed(times))
return -EFAULT;
times->tms_utime = m_ticks_in_user;
times->tms_stime = m_ticks_in_kernel;
times->tms_cutime = m_ticks_in_user_for_dead_children;
times->tms_cstime = m_ticks_in_kernel_for_dead_children;
Kernel: Make the times() syscall return something other than 0. Based on the description I read, this syscall doesn't seem completely reasonable, but let's at least return a number that is likely to change between invocations in case somebody depends on that happening.
2019-05-17 18:19:29 +00:00
return g_uptime & 0x7fffffff;
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
}
Switch into 1024x768x32bpp VESA LFB mode at boot. This is going to be pretty cool once I can hook up the Widgets/ code to it.
2019-01-09 01:29:11 +00:00
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
int Process::sys$select(const Syscall::SC_select_params* params)
{
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
// FIXME: Return -EINVAL if timeout is invalid.
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [nfds, readfds, writefds, exceptfds, timeout] = *params;
if (writefds && !validate_write_typed(writefds))
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (readfds && !validate_write_typed(readfds))
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (exceptfds && !validate_write_typed(exceptfds))
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (timeout && !validate_read_typed(timeout))
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (nfds < 0)
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
return -EINVAL;
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
timeval computed_timeout;
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
bool select_has_timeout = false;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (timeout && (timeout->tv_sec || timeout->tv_usec)) {
timeval_add(kgettimeofday(), *timeout, computed_timeout);
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
select_has_timeout = true;
Implement event loop timers. GObjects can now register a timer with the GEventLoop. This will eventually cause GTimerEvents to be dispatched to the GObject. This needed a few supporting changes in the kernel: - The PIT now ticks 1000 times/sec. - select() now supports an arbitrary timeout. - gettimeofday() now returns something in the tv_usec field. With these changes, the clock window in guitest2 finally ticks on its own.
2019-02-01 02:50:06 +00:00
}
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
Kernel: Avoid allocations for Select vectors by using inline capacity Good tip by Andreas :)
2019-07-19 07:04:12 +00:00
Thread::SelectBlocker::FDVector rfds;
Thread::SelectBlocker::FDVector wfds;
Thread::SelectBlocker::FDVector efds;
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
auto transfer_fds = [&](auto* fds, auto& vector) -> int {
Kernel: Make sure to clear FD sets when preparing for a select NULL sets can happen, and we don't want to incorrectly return FDs which aren't in the set too.
2019-05-18 00:00:54 +00:00
vector.clear_with_capacity();
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
if (!fds)
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
return 0;
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
for (int fd = 0; fd < params->nfds; ++fd) {
if (FD_ISSET(fd, fds)) {
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 08:33:37 +00:00
if (!file_description(fd)) {
dbg() << *current << " sys$select: Bad fd number " << fd;
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
return -EBADF;
WindowServer: Port to the new IPC system This patch introduces code generation for the WindowServer IPC with its clients. The client/server endpoints are defined by the two .ipc files in Servers/WindowServer/: WindowServer.ipc and WindowClient.ipc It now becomes significantly easier to add features and capabilities to WindowServer since you don't have to know nearly as much about all the intricate paths that IPC messages take between LibGUI and WSWindow. The new system also uses significantly less IPC bandwidth since we're now doing packed serialization instead of passing fixed-sized structs of ~600 bytes for each message. Some repaint coalescing optimizations are lost in this conversion and we'll need to look at how to implement those in the new world. The old CoreIPC::Client::Connection and CoreIPC::Server::Connection classes are removed by this patch and replaced by use of ConnectionNG, which will be renamed eventually. Goodbye, old WindowServer IPC. You served us well :^)
2019-12-02 08:33:37 +00:00
}
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
vector.append(fd);
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
}
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
}
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
return 0;
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
};
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (int error = transfer_fds(writefds, wfds))
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
return error;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (int error = transfer_fds(readfds, rfds))
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
return error;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (int error = transfer_fds(exceptfds, efds))
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
return error;
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
Kernel: Add the ability to debug poll/select independently of read/write
2019-05-19 08:24:28 +00:00
#if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
dbgprintf("%s<%u> selecting on (read:%u, write:%u), timeout=%p\n", name().characters(), pid(), rfds.size(), wfds.size(), timeout);
Rework WindowServer to use select() in its main event loop. The system can finally idle without burning CPU. :^) There are some issues with scheduling making the mouse cursor sloppy and unresponsive that need to be dealt with.
2019-01-16 16:20:58 +00:00
#endif
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (!timeout || select_has_timeout) {
if (current->block<Thread::SelectBlocker>(computed_timeout, select_has_timeout, rfds, wfds, efds) == Thread::BlockResult::InterruptedBySignal)
Process: Fix select/poll EINTR Check for EINTR before doing anything with the passed sets, otherwise we zero them out which means a re-call with the same sets won't work.
2019-07-21 11:31:20 +00:00
return -EINTR;
}
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
int marked_fd_count = 0;
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
auto mark_fds = [&](auto* fds, auto& vector, auto should_mark) {
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
if (!fds)
return;
FD_ZERO(fds);
for (int fd : vector) {
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (auto* description = file_description(fd); description && should_mark(*description)) {
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
FD_SET(fd, fds);
++marked_fd_count;
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
}
}
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
};
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
mark_fds(readfds, rfds, [](auto& description) { return description.can_read(); });
mark_fds(writefds, wfds, [](auto& description) { return description.can_write(); });
// FIXME: We should also mark exceptfds as appropriate.
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
Kernel: Tidy up sys$select() to make it more readable.
2019-06-06 15:46:41 +00:00
return marked_fd_count;
Implement basic support for POSIX-style select(). Now we can block on both the PTY *and* the GUI event stream in Terminal.
2019-01-15 22:12:20 +00:00
}
Rework WindowServer to use select() in its main event loop. The system can finally idle without burning CPU. :^) There are some issues with scheduling making the mouse cursor sloppy and unresponsive that need to be dealt with.
2019-01-16 16:20:58 +00:00
Stub out poll() syscall and LibC wrapper.
2019-01-23 06:27:41 +00:00
int Process::sys$poll(pollfd* fds, int nfds, int timeout)
{
if (!validate_read_typed(fds))
return -EFAULT;
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
Kernel: Avoid allocations for Select vectors by using inline capacity Good tip by Andreas :)
2019-07-19 07:04:12 +00:00
Thread::SelectBlocker::FDVector rfds;
Thread::SelectBlocker::FDVector wfds;
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
for (int i = 0; i < nfds; ++i) {
if (fds[i].events & POLLIN)
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
rfds.append(fds[i].fd);
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
if (fds[i].events & POLLOUT)
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
wfds.append(fds[i].fd);
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
}
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
timeval actual_timeout;
bool has_timeout = false;
Kernel: Fix poll() with timeout
2019-05-18 01:59:48 +00:00
if (timeout >= 0) {
// poll is in ms, we want s/us.
struct timeval tvtimeout;
tvtimeout.tv_sec = 0;
while (timeout >= 1000) {
tvtimeout.tv_sec += 1;
timeout -= 1000;
}
tvtimeout.tv_usec = timeout * 1000;
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
timeval_add(kgettimeofday(), tvtimeout, actual_timeout);
has_timeout = true;
Kernel: Fix poll() with timeout
2019-05-18 01:59:48 +00:00
}
Kernel: Add the ability to debug poll/select independently of read/write
2019-05-19 08:24:28 +00:00
#if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
Kernel: Port select to ThreadBlocker
2019-07-18 15:39:49 +00:00
dbgprintf("%s<%u> polling on (read:%u, write:%u), timeout=%d\n", name().characters(), pid(), rfds.size(), wfds.size(), timeout);
Kernel: Add the ability to debug poll/select independently of read/write
2019-05-19 08:24:28 +00:00
#endif
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
if (has_timeout || timeout < 0) {
Process: Fix select/poll EINTR Check for EINTR before doing anything with the passed sets, otherwise we zero them out which means a re-call with the same sets won't work.
2019-07-21 11:31:20 +00:00
if (current->block<Thread::SelectBlocker>(actual_timeout, has_timeout, rfds, wfds, Thread::SelectBlocker::FDVector()) == Thread::BlockResult::InterruptedBySignal)
return -EINTR;
}
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
int fds_with_revents = 0;
for (int i = 0; i < nfds; ++i) {
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fds[i].fd);
if (!description) {
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
fds[i].revents = POLLNVAL;
continue;
}
fds[i].revents = 0;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (fds[i].events & POLLIN && description->can_read())
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
fds[i].revents |= POLLIN;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (fds[i].events & POLLOUT && description->can_write())
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
fds[i].revents |= POLLOUT;
if (fds[i].revents)
++fds_with_revents;
}
return fds_with_revents;
Stub out poll() syscall and LibC wrapper.
2019-01-23 06:27:41 +00:00
}
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
Custody& Process::current_directory()
Rework WindowServer to use select() in its main event loop. The system can finally idle without burning CPU. :^) There are some issues with scheduling making the mouse cursor sloppy and unresponsive that need to be dealt with.
2019-01-16 16:20:58 +00:00
{
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
if (!m_cwd)
m_cwd = VFS::the().root_custody();
return *m_cwd;
Rework WindowServer to use select() in its main event loop. The system can finally idle without burning CPU. :^) There are some issues with scheduling making the mouse cursor sloppy and unresponsive that need to be dealt with.
2019-01-16 16:20:58 +00:00
}
Add unlink() syscall and /bin/rm. This patch adds most of the plumbing for working file deletion in Ext2FS. Directory entries are removed and inode link counts updated. We don't yet update the inode or block bitmaps, I will do that separately.
2019-01-22 06:03:44 +00:00
Kernel: Add link() syscall to create hard links. This accidentally grew into a little bit of VFS cleanup as well. Also add a simple /bin/ln implementation to exercise it.
2019-02-21 12:26:40 +00:00
int Process::sys$link(const char* old_path, const char* new_path)
{
if (!validate_read_str(old_path))
return -EFAULT;
if (!validate_read_str(new_path))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().link(StringView(old_path), StringView(new_path), current_directory());
Kernel: Add link() syscall to create hard links. This accidentally grew into a little bit of VFS cleanup as well. Also add a simple /bin/ln implementation to exercise it.
2019-02-21 12:26:40 +00:00
}
Add unlink() syscall and /bin/rm. This patch adds most of the plumbing for working file deletion in Ext2FS. Directory entries are removed and inode link counts updated. We don't yet update the inode or block bitmaps, I will do that separately.
2019-01-22 06:03:44 +00:00
int Process::sys$unlink(const char* pathname)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().unlink(StringView(pathname), current_directory());
Add unlink() syscall and /bin/rm. This patch adds most of the plumbing for working file deletion in Ext2FS. Directory entries are removed and inode link counts updated. We don't yet update the inode or block bitmaps, I will do that separately.
2019-01-22 06:03:44 +00:00
}
Terminal: Redraw entire line if any of its characters are dirty. This means we only have to do one fill_rect() per line and the whole process ends up being ~10% faster than before. Also added a read_tsc() syscall to give userspace access to the TSC.
2019-01-25 01:09:29 +00:00
Kernel+Userland: Add symlink() syscall and add "-s" flag to /bin/ln. It's now possible to create symbolic links! :^) This exposed an issue in Ext2FS where we'd write uninitialized data past the end of an inode's content. Fix this by zeroing out the tail end of the last block in a file.
2019-03-02 00:50:34 +00:00
int Process::sys$symlink(const char* target, const char* linkpath)
{
if (!validate_read_str(target))
return -EFAULT;
if (!validate_read_str(linkpath))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().symlink(StringView(target), StringView(linkpath), current_directory());
Kernel+Userland: Add symlink() syscall and add "-s" flag to /bin/ln. It's now possible to create symbolic links! :^) This exposed an issue in Ext2FS where we'd write uninitialized data past the end of an inode's content. Fix this by zeroing out the tail end of the last block in a file.
2019-03-02 00:50:34 +00:00
}
Add support for removing directories. It's really only supported in Ext2FS since SynthFS doesn't really want you mucking around with its files. This is pretty neat though :^) I ran into some trouble with HashMap while working on this but opted to work around it and leave that for a separate investigation.
2019-01-28 03:16:01 +00:00
int Process::sys$rmdir(const char* pathname)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().rmdir(StringView(pathname), current_directory());
Add support for removing directories. It's really only supported in Ext2FS since SynthFS doesn't really want you mucking around with its files. This is pretty neat though :^) I ran into some trouble with HashMap while working on this but opted to work around it and leave that for a separate investigation.
2019-01-28 03:16:01 +00:00
}
Implement basic chmod() syscall and /bin/chmod helper. Only raw octal modes are supported right now. This patch also changes mode_t from 32-bit to 16-bit to match the on-disk type used by Ext2FS. I also ran into EPERM being errno=0 which was confusing, so I inserted an ESUCCESS in its place.
2019-01-29 03:55:08 +00:00
int Process::sys$chmod(const char* pathname, mode_t mode)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().chmod(StringView(pathname), mode, current_directory());
Implement basic chmod() syscall and /bin/chmod helper. Only raw octal modes are supported right now. This patch also changes mode_t from 32-bit to 16-bit to match the on-disk type used by Ext2FS. I also ran into EPERM being errno=0 which was confusing, so I inserted an ESUCCESS in its place.
2019-01-29 03:55:08 +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
Kernel+Userland: Implement fchmod() syscall and use it to improve /bin/cp. /bin/cp will now copy the permission bits from source to destination. :^)
2019-03-01 09:39:19 +00:00
int Process::sys$fchmod(int fd, mode_t mode)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Kernel+Userland: Implement fchmod() syscall and use it to improve /bin/cp. /bin/cp will now copy the permission bits from source to destination. :^)
2019-03-01 09:39:19 +00:00
return -EBADF;
Kernel: Allow fchmod() and fchown() on pre-bind() local sockets In order to ensure a specific owner and mode when the local socket filesystem endpoint is instantiated, we need to be able to call fchmod() and fchown() on a socket fd between socket() and bind(). This is because until we call bind(), there is no filesystem inode for the socket yet.
2020-01-03 19:14:56 +00:00
return description->chmod(mode);
Kernel+Userland: Implement fchmod() syscall and use it to improve /bin/cp. /bin/cp will now copy the permission bits from source to destination. :^)
2019-03-01 09:39:19 +00:00
}
Kernel: Add fchown() syscall.
2019-06-01 18:31:36 +00:00
int Process::sys$fchown(int fd, uid_t uid, gid_t gid)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Kernel: Add fchown() syscall.
2019-06-01 18:31:36 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->chown(uid, gid);
Kernel: Add fchown() syscall.
2019-06-01 18:31:36 +00:00
}
Add chown() syscall and a simple /bin/chown program.
2019-02-27 11:32:53 +00:00
int Process::sys$chown(const char* pathname, uid_t uid, gid_t gid)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().chown(StringView(pathname), uid, gid, current_directory());
Add chown() syscall and a simple /bin/chown program.
2019-02-27 11:32:53 +00:00
}
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
void Process::finalize()
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
{
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
ASSERT(current == g_finalizer);
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
dbgprintf("Finalizing Process %s(%u)\n", m_name.characters(), m_pid);
Kernel: Various stability improvements. - Don't cli() in Process::do_exec() unless current is execing. Eventually this should go away once the scheduler is less retarded in the face of interrupts. - Improved memory access validation for ring0 processes. We now look at the kernel ELF header to determine if an access is appropriate. :^) It's very hackish but also kinda neat. - Have Process::die() put the process into a new "Dying" state where it can still get scheduled but no signals will be dispatched. This way we can keep executing in die() but won't get our EIP hijacked by signal dispatch. The main problem here was that die() wanted to take various locks.
2019-02-06 16:28:14 +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
m_fds.clear();
Kernel: Process should disassociate from its TTY when it dies. Just because we die doesn't mean we got waited on yet, so keeping around a dangling TTY pointer is just asking for trouble.
2019-02-04 09:21:15 +00:00
m_tty = nullptr;
Kernel: Process finalization should release cwd and executable custodies. Since Process destruction happens with interrupts disabled, it's not safe to still hold custodies at that point. Drop them in finalization.
2019-05-31 05:19:54 +00:00
m_executable = nullptr;
m_cwd = nullptr;
Kernel: Discard a process's ELFLoader on finalization. We don't need after that point, and throwing it out might free up some cached data used for backtraces.
2019-05-31 06:03:58 +00:00
m_elf_loader = nullptr;
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
disown_all_shared_buffers();
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
{
InterruptDisabler disabler;
if (auto* parent_process = Process::from_pid(m_ppid)) {
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
// FIXME(Thread): What should we do here? Should we look at all threads' signal actions?
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
if (parent_process->thread_count() && parent_process->any_thread().m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT) {
Kernel: Don't send SIGCHLD to parent process if he has SA_NOCLDWAIT set. Just transfer ownership of the dead process to the colonel and let the scheduler reap it on next iteration.
2019-03-01 14:47:07 +00:00
// NOTE: If the parent doesn't care about this process, let it go.
m_ppid = 0;
} else {
parent_process->send_signal(SIGCHLD, this);
}
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
}
Kernel: Process should send SIGCHLD to its parent when it dies.
2019-02-04 12:30:03 +00:00
}
Kernel: Fix broken destruction order for Process/Thread.
2019-03-24 00:20:35 +00:00
m_dead = true;
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
}
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
void Process::die()
{
Kernel: Process should release its TTY immediately on exit Don't wait for someone to wait() on a dead process before releasing its TTY object. This fixes the child process death detection used by the Terminal application, which relies on getting an EOF on the master PTY in order to know it's time to wait() on the child process. :^)
2019-11-10 07:49:23 +00:00
// Let go of the TTY, otherwise a slave PTY may keep the master PTY from
// getting an EOF when the last process using the slave PTY dies.
// If the master PTY owner relies on an EOF to know when to wait() on a
// slave owner, we have to allow the PTY pair to be torn down.
m_tty = nullptr;
Kernel: Add a systrace() syscall and implement /bin/strace using it. Calling systrace(pid) gives you a file descriptor with a stream of the syscalls made by a peer process. The process must be owned by the same UID who calls systrace(). :^)
2019-04-22 16:44:45 +00:00
if (m_tracer)
m_tracer->set_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: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
// Tell the threads to unwind and die.
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
InterruptDisabler disabler;
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
for_each_thread([](Thread& thread) {
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
thread.set_should_die();
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
return IterationDecision::Continue;
});
}
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
}
Kernel+SystemMonitor: Expose amount of per-process dirty private memory Dirty private memory is all memory in non-inode-backed mappings that's process-private, meaning it's not shared with any other process. This patch exposes that number via SystemMonitor, giving us an idea of how much memory each process is responsible for all on its own.
2019-12-29 11:28:32 +00:00
size_t Process::amount_dirty_private() const
{
Kernel+SystemMonitor: Expose amount of per-process clean inode memory This is memory that's loaded from an inode (file) but not modified in memory, so still identical to what's on disk. This kind of memory can be freed and reloaded transparently from disk if needed.
2019-12-29 11:45:58 +00:00
// FIXME: This gets a bit more complicated for Regions sharing the same underlying VMObject.
// The main issue I'm thinking of is when the VMObject has physical pages that none of the Regions are mapping.
// That's probably a situation that needs to be looked at in general.
Kernel+SystemMonitor: Expose amount of per-process dirty private memory Dirty private memory is all memory in non-inode-backed mappings that's process-private, meaning it's not shared with any other process. This patch exposes that number via SystemMonitor, giving us an idea of how much memory each process is responsible for all on its own.
2019-12-29 11:28:32 +00:00
size_t amount = 0;
for (auto& region : m_regions) {
if (!region.is_shared())
amount += region.amount_dirty();
}
return amount;
}
Kernel+SystemMonitor: Expose amount of per-process clean inode memory This is memory that's loaded from an inode (file) but not modified in memory, so still identical to what's on disk. This kind of memory can be freed and reloaded transparently from disk if needed.
2019-12-29 11:45:58 +00:00
size_t Process::amount_clean_inode() const
{
HashTable<const InodeVMObject*> vmobjects;
for (auto& region : m_regions) {
if (region.vmobject().is_inode())
vmobjects.set(&static_cast<const InodeVMObject&>(region.vmobject()));
}
size_t amount = 0;
for (auto& vmobject : vmobjects)
amount += vmobject->amount_clean();
return amount;
}
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
size_t Process::amount_virtual() const
{
size_t amount = 0;
for (auto& region : m_regions) {
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
amount += region.size();
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
}
return amount;
}
size_t Process::amount_resident() const
{
// FIXME: This will double count if multiple regions use the same physical page.
size_t amount = 0;
for (auto& region : m_regions) {
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
amount += region.amount_resident();
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
}
return amount;
}
size_t Process::amount_shared() const
{
// FIXME: This will double count if multiple regions use the same physical page.
Change "retain" to "ref" in various comments.
2019-06-21 16:40:24 +00:00
// FIXME: It doesn't work at the moment, since it relies on PhysicalPage ref counts,
AK: Rename Retainable => RefCounted. (And various related renames that go along with it.)
2019-06-21 13:29:31 +00:00
// and each PhysicalPage is only reffed by its VMObject. This needs to be refactored
Change "retain" to "ref" in various comments.
2019-06-21 16:40:24 +00:00
// so that every Region contributes +1 ref to each of its PhysicalPages.
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
size_t amount = 0;
for (auto& region : m_regions) {
Kernel: Use NonnullRefPtrVector in parts of the kernel.
2019-06-27 11:34:28 +00:00
amount += region.amount_shared();
Kernel: Add a /proc/all process table dump. This will be useful for implementing some process-related utilities.
2019-02-03 17:53:18 +00:00
}
return amount;
}
Kernel: Add a Finalizer process to take care of dying processes. Instead of processes themselves getting scheduled to finish dying, let's have a Finalizer process that wakes up whenever someone is dying. This way we can do all kinds of lock-taking in process cleanup without risking reentering the scheduler.
2019-02-06 17:45:21 +00:00
Kernel: Start implementing purgeable memory support It's now possible to get purgeable memory by using mmap(MAP_PURGEABLE). Purgeable memory has a "volatile" flag that can be set using madvise(): - madvise(..., MADV_SET_VOLATILE) - madvise(..., MADV_SET_NONVOLATILE) When in the "volatile" state, the kernel may take away the underlying physical memory pages at any time, without notifying the owner. This gives you a guilt discount when caching very large things. :^) Setting a purgeable region to non-volatile will return whether or not the memory has been taken away by the kernel while being volatile. Basically, if madvise(..., MADV_SET_NONVOLATILE) returns 1, that means the memory was purged while volatile, and whatever was in that piece of memory needs to be reconstructed before use.
2019-12-09 18:12:38 +00:00
size_t Process::amount_purgeable_volatile() const
{
size_t amount = 0;
for (auto& region : m_regions) {
if (region.vmobject().is_purgeable() && static_cast<const PurgeableVMObject&>(region.vmobject()).is_volatile())
amount += region.amount_resident();
}
return amount;
}
size_t Process::amount_purgeable_nonvolatile() const
{
size_t amount = 0;
for (auto& region : m_regions) {
if (region.vmobject().is_purgeable() && !static_cast<const PurgeableVMObject&>(region.vmobject()).is_volatile())
amount += region.amount_resident();
}
return amount;
}
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
int Process::sys$socket(int domain, int type, int protocol)
{
Kernel+ping: Only allow superuser to create SOCK_RAW sockets /bin/ping is now setuid-root, and will drop privileges immediately after opening a raw socket.
2019-12-31 00:42:34 +00:00
if ((type & SOCK_TYPE_MASK) == SOCK_RAW && !is_superuser())
return -EACCES;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int fd = alloc_fd();
if (fd < 0)
return fd;
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
auto result = Socket::create(domain, type, protocol);
if (result.is_error())
return result.error();
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto description = FileDescription::create(*result.value());
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
description->set_readable(true);
description->set_writable(true);
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
unsigned flags = 0;
if (type & SOCK_CLOEXEC)
Kernel: socket() with SOCK_CLOEXEC was setting the wrong fd flag. Turns out FD_CLOEXEC and O_CLOEXEC are different values. Silly mistake. I noticed that Terminal's shell process still had the Terminal's window server connection open, albeit in a broken state.
2019-02-17 09:41:37 +00:00
flags |= FD_CLOEXEC;
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
if (type & SOCK_NONBLOCK)
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description->set_blocking(false);
m_fds[fd].set(move(description), flags);
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
return fd;
}
Kernel: Begin fleshing out bind() syscall.
2019-02-14 13:38:30 +00:00
int Process::sys$bind(int sockfd, const sockaddr* address, socklen_t address_length)
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
{
Kernel: Begin fleshing out bind() syscall.
2019-02-14 13:38:30 +00:00
if (!validate_read(address, address_length))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel: Begin fleshing out bind() syscall.
2019-02-14 13:38:30 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel: Begin fleshing out bind() syscall.
2019-02-14 13:38:30 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
return socket.bind(address, address_length);
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
}
int Process::sys$listen(int sockfd, int backlog)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: listen() should fail with EINVAL for already-connected sockets This according to POSIX.
2019-11-27 15:01:22 +00:00
if (socket.is_connected())
return -EINVAL;
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
return socket.listen(backlog);
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
}
WindowServer: Slurp all available client messages when checking them. We were reading one client message per client per event loop iteration. That was not very snappy. Make the sockets non-blocking and read() until there are no messages left. It would be even better to make as few calls to read() as possible to reduce context switching, but this is already a huge improvement.
2019-02-15 10:43:43 +00:00
int Process::sys$accept(int accepting_socket_fd, sockaddr* address, socklen_t* address_size)
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
{
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
if (!validate_write_typed(address_size))
return -EFAULT;
if (!validate_write(address, *address_size))
return -EFAULT;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int accepted_socket_fd = alloc_fd();
if (accepted_socket_fd < 0)
return accepted_socket_fd;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* accepting_socket_description = file_description(accepting_socket_fd);
if (!accepting_socket_description)
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!accepting_socket_description->is_socket())
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *accepting_socket_description->socket();
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
if (!socket.can_accept()) {
Kernel: Add a new block state for accept() on a blocking socket Rather than asserting, which really ruins everyone's day.
2019-07-18 08:39:00 +00:00
if (accepting_socket_description->is_blocking()) {
Thread: Return a result from block() indicating why the block terminated And use this to return EINTR in various places; some of which we were not handling properly before. This might expose a few bugs in userspace, but should be more compatible with other POSIX systems, and is certainly a little cleaner.
2019-07-20 09:05:52 +00:00
if (current->block<Thread::AcceptBlocker>(*accepting_socket_description) == Thread::BlockResult::InterruptedBySignal)
Kernel: Add a new block state for accept() on a blocking socket Rather than asserting, which really ruins everyone's day.
2019-07-18 08:39:00 +00:00
return -EINTR;
} else {
return -EAGAIN;
}
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
}
WindowServer: Slurp all available client messages when checking them. We were reading one client message per client per event loop iteration. That was not very snappy. Make the sockets non-blocking and read() until there are no messages left. It would be even better to make as few calls to read() as possible to reduce context switching, but this is already a huge improvement.
2019-02-15 10:43:43 +00:00
auto accepted_socket = socket.accept();
ASSERT(accepted_socket);
Kernel: Make accept() fill address with peer name rather than local name
2019-08-10 02:25:30 +00:00
bool success = accepted_socket->get_peer_address(address, address_size);
Kernel: More work on sockets. Getting there..
2019-02-14 14:40:04 +00:00
ASSERT(success);
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
auto accepted_socket_description = FileDescription::create(*accepted_socket);
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
accepted_socket_description->set_readable(true);
accepted_socket_description->set_writable(true);
WindowServer: Slurp all available client messages when checking them. We were reading one client message per client per event loop iteration. That was not very snappy. Make the sockets non-blocking and read() until there are no messages left. It would be even better to make as few calls to read() as possible to reduce context switching, but this is already a huge improvement.
2019-02-15 10:43:43 +00:00
// NOTE: The accepted socket inherits fd flags from the accepting socket.
// I'm not sure if this matches other systems but it makes sense to me.
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
accepted_socket_description->set_blocking(accepting_socket_description->is_blocking());
m_fds[accepted_socket_fd].set(move(accepted_socket_description), m_fds[accepting_socket_fd].flags);
Kernel: Delay moving accepted sockets to SetupState::Completed a bit Make sure we don't move accepted sockets to the Completed setup state until we've actually constructed a FileDescription for them. This is important, since this state transition will trigger connect() to unblock on the client side, and the client may try writing to the socket right away. This makes DNS lookups way more reliable since we don't just fail to write() right after connect()ing to LookupServer sometimes. :^)
2019-10-08 19:41:46 +00:00
// NOTE: Moving this state to Completed is what causes connect() to unblock on the client side.
accepted_socket->set_setup_state(Socket::SetupState::Completed);
WindowServer: Slurp all available client messages when checking them. We were reading one client message per client per event loop iteration. That was not very snappy. Make the sockets non-blocking and read() until there are no messages left. It would be even better to make as few calls to read() as possible to reduce context switching, but this is already a huge improvement.
2019-02-15 10:43:43 +00:00
return accepted_socket_fd;
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
}
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
int Process::sys$connect(int sockfd, const sockaddr* address, socklen_t address_size)
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
{
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
if (!validate_read(address, address_size))
return -EFAULT;
Kernel: Use alloc_fd() more instead of walking fd list manually.
2019-04-06 12:54:32 +00:00
int fd = alloc_fd();
if (fd < 0)
return fd;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
return -ENOTSOCK;
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Move socket role tracking to the Socket class itself This is more logical and allows us to solve the problem of non-blocking TCP sockets getting stuck in SocketRole::None. The only complication is that a single LocalSocket may be shared between two file descriptions (on the connect and accept sides), and should have two different roles depending from which side you look at it. To deal with it, Socket::role() is made a virtual method that accepts a file description, and LocalSocket internally tracks which FileDescription is the which one and returns a correct role.
2019-08-11 13:38:20 +00:00
return socket.connect(*description, address, address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
Port the WindowServer and LibGUI to communicate through local sockets. This is really cool! :^) Apps currently refuse to start if the WindowServer isn't listening on the socket in /wsportal. This makes sense, but I guess it would also be nice to have some sort of "wait for server on startup" mode. This has performance issues, and I'll work on those, but this stuff seems to actually work and I'm very happy with that.
2019-02-14 16:18:35 +00:00
}
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
ssize_t Process::sys$sendto(const Syscall::SC_sendto_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [sockfd, data, data_length, flags, addr, addr_length] = *params;
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
if (!validate_read(data, data_length))
return -EFAULT;
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
if (addr && !validate_read(addr, addr_length))
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
return socket.sendto(*description, data, data_length, flags, addr, addr_length);
Kernel+LibC+Userland: Start working on an IPv4 socket backend. The first userland networking program will be "ping" :^)
2019-03-12 14:51:42 +00:00
}
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
ssize_t Process::sys$recvfrom(const Syscall::SC_recvfrom_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [sockfd, buffer, buffer_length, flags, addr, addr_length] = *params;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
if (!validate_write(buffer, buffer_length))
return -EFAULT;
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
if (addr_length) {
IPv4: Save the source address/port together with incoming packet payloads. We need the address/port to fill in the out-params in recvfrom(). It should now be more or less possible to create a UDP server. :^)
2019-05-04 01:27:50 +00:00
if (!validate_write_typed(addr_length))
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
return -EFAULT;
IPv4: Save the source address/port together with incoming packet payloads. We need the address/port to fill in the out-params in recvfrom(). It should now be more or less possible to create a UDP server. :^)
2019-05-04 01:27:50 +00:00
if (!validate_write(addr, *addr_length))
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
return -EFAULT;
} else if (addr) {
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
return -EINVAL;
IPv4: More hacking on bringing up TCP support. This was a bit more complicated than I expected, but it's moving forward.
2019-03-13 22:14:30 +00:00
}
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Add support for recv() with MSG_DONTWAIT. Passing this flag to recv() temporarily puts the file descriptor into non-blocking mode. Also implement LocalSocket::recv() as a simple forwarding to read().
2019-05-20 01:44:45 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
bool original_blocking = description->is_blocking();
Kernel: Add support for recv() with MSG_DONTWAIT. Passing this flag to recv() temporarily puts the file descriptor into non-blocking mode. Also implement LocalSocket::recv() as a simple forwarding to read().
2019-05-20 01:44:45 +00:00
if (flags & MSG_DONTWAIT)
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description->set_blocking(false);
Kernel: Add support for recv() with MSG_DONTWAIT. Passing this flag to recv() temporarily puts the file descriptor into non-blocking mode. Also implement LocalSocket::recv() as a simple forwarding to read().
2019-05-20 01:44:45 +00:00
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto nrecv = socket.recvfrom(*description, buffer, buffer_length, flags, addr, addr_length);
Kernel: Add support for recv() with MSG_DONTWAIT. Passing this flag to recv() temporarily puts the file descriptor into non-blocking mode. Also implement LocalSocket::recv() as a simple forwarding to read().
2019-05-20 01:44:45 +00:00
if (flags & MSG_DONTWAIT)
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description->set_blocking(original_blocking);
Kernel: Add support for recv() with MSG_DONTWAIT. Passing this flag to recv() temporarily puts the file descriptor into non-blocking mode. Also implement LocalSocket::recv() as a simple forwarding to read().
2019-05-20 01:44:45 +00:00
return nrecv;
Kernel+LibC+Userland: Yet more networking bringup hacking. All ICMP sockets now receive all ICMP packets. All this buffering is gonna need some limits and such.
2019-03-12 16:27:07 +00:00
}
Kernel+LibC: Implement getsockname() syscall.
2019-05-19 17:55:27 +00:00
int Process::sys$getsockname(int sockfd, sockaddr* addr, socklen_t* addrlen)
{
if (!validate_read_typed(addrlen))
return -EFAULT;
if (*addrlen <= 0)
return -EINVAL;
if (!validate_write(addr, *addrlen))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel+LibC: Implement getsockname() syscall.
2019-05-19 17:55:27 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel+LibC: Implement getsockname() syscall.
2019-05-19 17:55:27 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
if (!socket.get_local_address(addr, addrlen))
return -EINVAL; // FIXME: Should this be another error? I'm not sure.
return 0;
}
int Process::sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen)
{
if (!validate_read_typed(addrlen))
return -EFAULT;
if (*addrlen <= 0)
return -EINVAL;
if (!validate_write(addr, *addrlen))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
Kernel: Use a more detailed state machine for socket setup
2019-08-10 03:17:00 +00:00
if (socket.setup_state() != Socket::SetupState::Completed)
Kernel: getpeername() should fail with ENOTCONN for non-connected sockets.
2019-05-23 13:39:52 +00:00
return -ENOTCONN;
Kernel: Add getpeername() syscall, and fix getsockname() behavior. We were copying the raw IPv4 addresses into the wrong part of sockaddr_in, and we didn't set sa_family or sa_port.
2019-05-20 18:33:03 +00:00
if (!socket.get_peer_address(addr, addrlen))
Kernel+LibC: Implement getsockname() syscall.
2019-05-19 17:55:27 +00:00
return -EINVAL; // FIXME: Should this be another error? I'm not sure.
return 0;
}
Kernel/LibC: Implement sched_* functionality to set/get process priority Right now, we allow anything inside a user to raise or lower any other process's priority. This feels simple enough to me. Linux disallows raising, but that's annoying in practice.
2019-05-29 21:20:51 +00:00
int Process::sys$sched_setparam(pid_t pid, const struct sched_param* param)
{
if (!validate_read_typed(param))
return -EFAULT;
InterruptDisabler disabler;
auto* peer = this;
if (pid != 0)
peer = Process::from_pid(pid);
if (!peer)
return -ESRCH;
if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
return -EPERM;
Kernel: Refactor scheduler to use dynamic thread priorities Threads now have numeric priorities with a base priority in the 1-99 range. Whenever a runnable thread is *not* scheduled, its effective priority is incremented by 1. This is tracked in Thread::m_extra_priority. The effective priority of a thread is m_priority + m_extra_priority. When a runnable thread *is* scheduled, its m_extra_priority is reset to zero and the effective priority returns to base. This means that lower-priority threads will always eventually get scheduled to run, once its effective priority becomes high enough to exceed the base priority of threads "above" it. The previous values for ThreadPriority (Low, Normal and High) are now replaced as follows: Low -> 10 Normal -> 30 High -> 50 In other words, it will take 20 ticks for a "Low" priority thread to get to "Normal" effective priority, and another 20 to reach "High". This is not perfect, and I've used some quite naive data structures, but I think the mechanism will allow us to build various new and interesting optimizations, and we can figure out better data structures later on. :^)
2019-12-30 17:46:17 +00:00
if (param->sched_priority < THREAD_PRIORITY_MIN || param->sched_priority > THREAD_PRIORITY_MAX)
Kernel/LibC: Implement sched_* functionality to set/get process priority Right now, we allow anything inside a user to raise or lower any other process's priority. This feels simple enough to me. Linux disallows raising, but that's annoying in practice.
2019-05-29 21:20:51 +00:00
return -EINVAL;
Kernel: Refactor scheduler to use dynamic thread priorities Threads now have numeric priorities with a base priority in the 1-99 range. Whenever a runnable thread is *not* scheduled, its effective priority is incremented by 1. This is tracked in Thread::m_extra_priority. The effective priority of a thread is m_priority + m_extra_priority. When a runnable thread *is* scheduled, its m_extra_priority is reset to zero and the effective priority returns to base. This means that lower-priority threads will always eventually get scheduled to run, once its effective priority becomes high enough to exceed the base priority of threads "above" it. The previous values for ThreadPriority (Low, Normal and High) are now replaced as follows: Low -> 10 Normal -> 30 High -> 50 In other words, it will take 20 ticks for a "Low" priority thread to get to "Normal" effective priority, and another 20 to reach "High". This is not perfect, and I've used some quite naive data structures, but I think the mechanism will allow us to build various new and interesting optimizations, and we can figure out better data structures later on. :^)
2019-12-30 17:46:17 +00:00
peer->any_thread().set_priority((u32)param->sched_priority);
Kernel/LibC: Implement sched_* functionality to set/get process priority Right now, we allow anything inside a user to raise or lower any other process's priority. This feels simple enough to me. Linux disallows raising, but that's annoying in practice.
2019-05-29 21:20:51 +00:00
return 0;
}
int Process::sys$sched_getparam(pid_t pid, struct sched_param* param)
{
if (!validate_read_typed(param))
return -EFAULT;
InterruptDisabler disabler;
auto* peer = this;
if (pid != 0)
peer = Process::from_pid(pid);
if (!peer)
return -ESRCH;
if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
return -EPERM;
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
param->sched_priority = (int)peer->any_thread().priority();
Kernel/LibC: Implement sched_* functionality to set/get process priority Right now, we allow anything inside a user to raise or lower any other process's priority. This feels simple enough to me. Linux disallows raising, but that's annoying in practice.
2019-05-29 21:20:51 +00:00
return 0;
}
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
int Process::sys$getsockopt(const Syscall::SC_getsockopt_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [sockfd, level, option, value, value_size] = *params;
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
if (!validate_write_typed(value_size))
return -EFAULT;
if (!validate_write(value, *value_size))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
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
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
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
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
Kernel: Add getsockopt(SO_PEERCRED) for local sockets This sockopt gives you a struct with the PID, UID and GID of a socket's peer process.
2019-12-06 17:38:36 +00:00
return socket.getsockopt(*description, level, option, value, value_size);
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
}
int Process::sys$setsockopt(const Syscall::SC_setsockopt_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [sockfd, level, option, value, value_size] = *params;
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
if (!validate_read(value, value_size))
return -EFAULT;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(sockfd);
if (!description)
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
return -EBADF;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
if (!description->is_socket())
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
return -ENOTSOCK;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto& socket = *description->socket();
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
return socket.setsockopt(level, option, value, value_size);
}
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
void Process::disown_all_shared_buffers()
{
LOCKER(shared_buffers().lock());
Sprinkle use of AK::Vector in various places. Some of these are less helpful than others. Avoiding a bunch of mallocs in the event loop wakeup code is definitely nice.
2019-04-20 12:02:19 +00:00
Vector<SharedBuffer*, 32> buffers_to_disown;
Kernel: Don't remove from SharedBuffer map while iterating it. This was causing a finalizer crash when handling a process that co-owned multiple shared buffers.
2019-02-20 20:31:52 +00:00
for (auto& it : shared_buffers().resource())
buffers_to_disown.append(it.value.ptr());
for (auto* shared_buffer : buffers_to_disown)
shared_buffer->disown(m_pid);
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
}
SharedBuffer: Split the creation and share steps This allows us to seal a buffer *before* anyone else has access to it (well, ok, the creating process still does, but you can't win them all). It also means that a SharedBuffer can be shared with multiple clients: all you need is to have access to it to share it on again.
2019-07-18 07:52:22 +00:00
int Process::sys$create_shared_buffer(int size, void** buffer)
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
{
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
if (!size || size < 0)
Kernel: Don't remove from SharedBuffer map while iterating it. This was causing a finalizer crash when handling a process that co-owned multiple shared buffers.
2019-02-20 20:31:52 +00:00
return -EINVAL;
size = PAGE_ROUND_UP(size);
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
if (!validate_write_typed(buffer))
return -EFAULT;
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
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
LOCKER(shared_buffers().lock());
SharedBuffer: Fix deadlock on destroy We were locking the list of references, and then destroying the reference, which made things go a little crazy. It's more straightforward to just remove the per-reference lock: the syscalls all have to lock the full list anyway, so let's just do that and avoid the hassle. While I'm at it, also move the SharedBuffer code out to its own file as it's getting a little long and unwieldly, and Process.cpp is already huge.
2019-07-16 13:03:39 +00:00
static int s_next_shared_buffer_id;
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
int shared_buffer_id = ++s_next_shared_buffer_id;
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
auto shared_buffer = make<SharedBuffer>(shared_buffer_id, size);
shared_buffer->share_with(m_pid);
SharedBuffer: Fix a denial of service It's a very bad idea to increment the refcount on behalf of another process. That process may (for either benign or evil reasons) not reference the SharedBuffer, and then we'll be stuck with loads of SharedBuffers until we OOM. Instead, increment the refcount when the buffer is mapped. That way, a buffer is only kept if *someone* has explicitly requested it via get_shared_buffer. Fixes #341
2019-07-19 15:46:21 +00:00
*buffer = shared_buffer->ref_for_process_and_get_address(*this);
Kernel: Fix all compiler warnings.
2019-06-22 14:22:34 +00:00
ASSERT((int)shared_buffer->size() >= size);
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#ifdef SHARED_BUFFER_DEBUG
Kernel: Rename vmo => vmobject everywhere
2019-12-19 18:13:44 +00:00
kprintf("%s(%u): Created shared buffer %d @ %p (%u bytes, vmobject is %u)\n", name().characters(), pid(), shared_buffer_id, *buffer, size, shared_buffer->size());
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#endif
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
shared_buffers().resource().set(shared_buffer_id, move(shared_buffer));
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
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
return shared_buffer_id;
}
SharedBuffer: Split the creation and share steps This allows us to seal a buffer *before* anyone else has access to it (well, ok, the creating process still does, but you can't win them all). It also means that a SharedBuffer can be shared with multiple clients: all you need is to have access to it to share it on again.
2019-07-18 07:52:22 +00:00
int Process::sys$share_buffer_with(int shared_buffer_id, pid_t peer_pid)
{
if (!peer_pid || peer_pid < 0 || peer_pid == m_pid)
return -EINVAL;
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
Kernel: Disallow access to shared buffers we're not allowed to access. Unless we're on the share list, make all shared buffer related syscalls return EPERM.
2019-07-28 05:11:14 +00:00
if (!shared_buffer.is_shared_with(m_pid))
return -EPERM;
SharedBuffer: Split the creation and share steps This allows us to seal a buffer *before* anyone else has access to it (well, ok, the creating process still does, but you can't win them all). It also means that a SharedBuffer can be shared with multiple clients: all you need is to have access to it to share it on again.
2019-07-18 07:52:22 +00:00
{
InterruptDisabler disabler;
auto* peer = Process::from_pid(peer_pid);
if (!peer)
return -ESRCH;
}
shared_buffer.share_with(peer_pid);
return 0;
}
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
int Process::sys$share_buffer_globally(int shared_buffer_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
if (!shared_buffer.is_shared_with(m_pid))
return -EPERM;
shared_buffer.share_globally();
return 0;
}
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
int Process::sys$release_shared_buffer(int shared_buffer_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
Kernel: Disallow access to shared buffers we're not allowed to access. Unless we're on the share list, make all shared buffer related syscalls return EPERM.
2019-07-28 05:11:14 +00:00
if (!shared_buffer.is_shared_with(m_pid))
return -EPERM;
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#ifdef SHARED_BUFFER_DEBUG
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
kprintf("%s(%u): Releasing shared buffer %d, buffer count: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#endif
SharedBuffer: Fix a denial of service It's a very bad idea to increment the refcount on behalf of another process. That process may (for either benign or evil reasons) not reference the SharedBuffer, and then we'll be stuck with loads of SharedBuffers until we OOM. Instead, increment the refcount when the buffer is mapped. That way, a buffer is only kept if *someone* has explicitly requested it via get_shared_buffer. Fixes #341
2019-07-19 15:46:21 +00:00
shared_buffer.deref_for_process(*this);
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
return 0;
}
void* Process::sys$get_shared_buffer(int shared_buffer_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return (void*)-EINVAL;
auto& shared_buffer = *(*it).value;
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
if (!shared_buffer.is_shared_with(m_pid))
Kernel: Disallow access to shared buffers we're not allowed to access. Unless we're on the share list, make all shared buffer related syscalls return EPERM.
2019-07-28 05:11:14 +00:00
return (void*)-EPERM;
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#ifdef SHARED_BUFFER_DEBUG
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
kprintf("%s(%u): Retaining shared buffer %d, buffer count: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
Move WindowServer to userspace. This is a monster patch that required changing a whole bunch of things. There are performance and stability issues all over the place, but it works. Pretty cool, I have to admit :^)
2019-02-16 23:13:47 +00:00
#endif
SharedBuffer: Fix a denial of service It's a very bad idea to increment the refcount on behalf of another process. That process may (for either benign or evil reasons) not reference the SharedBuffer, and then we'll be stuck with loads of SharedBuffers until we OOM. Instead, increment the refcount when the buffer is mapped. That way, a buffer is only kept if *someone* has explicitly requested it via get_shared_buffer. Fixes #341
2019-07-19 15:46:21 +00:00
return shared_buffer.ref_for_process_and_get_address(*this);
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: Block a signal from being dispatched again until handler returns. We don't handle nesting yet, but this is a step in the right direction.
2019-03-05 09:34:08 +00:00
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
int Process::sys$seal_shared_buffer(int shared_buffer_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
if (!shared_buffer.is_shared_with(m_pid))
Kernel: Disallow access to shared buffers we're not allowed to access. Unless we're on the share list, make all shared buffer related syscalls return EPERM.
2019-07-28 05:11:14 +00:00
return -EPERM;
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
#ifdef SHARED_BUFFER_DEBUG
kprintf("%s(%u): Sealing shared buffer %d\n", name().characters(), pid(), shared_buffer_id);
#endif
shared_buffer.seal();
return 0;
}
int Process::sys$get_shared_buffer_size(int shared_buffer_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
Kernel: SharedBuffer sharing cleanup Rather than limiting it to two shared processes, store a Vector of references, so we can add more if we want. Makes the code a little more generic. No actual change to the syscall interface yet, so nothing takes advantage of this yet.
2019-07-15 18:38:41 +00:00
if (!shared_buffer.is_shared_with(m_pid))
Kernel: Disallow access to shared buffers we're not allowed to access. Unless we're on the share list, make all shared buffer related syscalls return EPERM.
2019-07-28 05:11:14 +00:00
return -EPERM;
Add a C++ helper class for working with shared buffers. This is a bit more comfortable than passing the shared buffer ID manually everywhere and keeping track of size etc.
2019-03-08 11:22:55 +00:00
#ifdef SHARED_BUFFER_DEBUG
kprintf("%s(%u): Get shared buffer %d size: %u\n", name().characters(), pid(), shared_buffer_id, shared_buffers().resource().size());
#endif
return shared_buffer.size();
}
Kernel+LibC: Make all SharedBuffers purgeable (default: non-volatile) This patch makes SharedBuffer use a PurgeableVMObject as its underlying memory object. A new syscall is added to control the volatile flag of a SharedBuffer.
2019-12-09 19:06:47 +00:00
int Process::sys$set_shared_buffer_volatile(int shared_buffer_id, bool state)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shared_buffer_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
if (!shared_buffer.is_shared_with(m_pid))
return -EPERM;
#ifdef SHARED_BUFFER_DEBUG
kprintf("%s(%u): Set shared buffer %d volatile: %u\n", name().characters(), pid(), shared_buffer_id, state);
#endif
if (!state) {
bool was_purged = shared_buffer.vmobject().was_purged();
shared_buffer.vmobject().set_volatile(state);
shared_buffer.vmobject().set_was_purged(false);
return was_purged ? 1 : 0;
}
shared_buffer.vmobject().set_volatile(true);
return 0;
}
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 Process::terminate_due_to_signal(u8 signal)
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
{
ASSERT_INTERRUPTS_DISABLED();
ASSERT(signal < 32);
dbgprintf("terminate_due_to_signal %s(%u) <- %u\n", name().characters(), pid(), signal);
m_termination_status = 0;
m_termination_signal = signal;
die();
}
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 Process::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
{
// FIXME(Thread): Find the appropriate thread to deliver the signal to.
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
any_thread().send_signal(signal, 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+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
int Process::sys$create_thread(void* (*entry)(void*), void* argument, const Syscall::SC_create_thread_params* params)
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
{
if (!validate_read((const void*)entry, sizeof(void*)))
return -EFAULT;
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
if (!validate_read_typed(params))
return -EFAULT;
u32 user_stack_address = reinterpret_cast<u32>(params->m_stack_location) + params->m_stack_size;
if (!MM.validate_user_stack(*this, VirtualAddress(user_stack_address - 4)))
Kernel+LibPthread+LibC: Create secondary thread stacks in userspace Have pthread_create() allocate a stack and passing it to the kernel instead of this work happening in the kernel. The more of this we can do in userspace, the better. This patch also unexposes the raw create_thread() and exit_thread() syscalls since they are now only used by LibPthread anyway.
2019-11-17 16:28:17 +00:00
return -EFAULT;
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
// FIXME: return EAGAIN if Thread::all_threads().size() is greater than PTHREAD_THREADS_MAX
Kernel: Refactor scheduler to use dynamic thread priorities Threads now have numeric priorities with a base priority in the 1-99 range. Whenever a runnable thread is *not* scheduled, its effective priority is incremented by 1. This is tracked in Thread::m_extra_priority. The effective priority of a thread is m_priority + m_extra_priority. When a runnable thread *is* scheduled, its m_extra_priority is reset to zero and the effective priority returns to base. This means that lower-priority threads will always eventually get scheduled to run, once its effective priority becomes high enough to exceed the base priority of threads "above" it. The previous values for ThreadPriority (Low, Normal and High) are now replaced as follows: Low -> 10 Normal -> 30 High -> 50 In other words, it will take 20 ticks for a "Low" priority thread to get to "Normal" effective priority, and another 20 to reach "High". This is not perfect, and I've used some quite naive data structures, but I think the mechanism will allow us to build various new and interesting optimizations, and we can figure out better data structures later on. :^)
2019-12-30 17:46:17 +00:00
int requested_thread_priority = params->m_schedule_priority;
if (requested_thread_priority < THREAD_PRIORITY_MIN || requested_thread_priority > THREAD_PRIORITY_MAX)
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
return -EINVAL;
bool is_thread_joinable = (0 == params->m_detach_state);
// FIXME: Do something with guard pages?
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
auto* thread = new Thread(*this);
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
// We know this thread is not the main_thread,
// So give it a unique name until the user calls $set_thread_name on it
// length + 4 to give space for our extra junk at the end
StringBuilder builder(m_name.length() + 4);
builder.append(m_name);
builder.appendf("[%d]", thread->tid());
thread->set_name(builder.to_string());
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
thread->set_priority(requested_thread_priority);
thread->set_joinable(is_thread_joinable);
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
auto& tss = thread->tss();
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
tss.eip = (u32)entry;
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
tss.eflags = 0x0202;
tss.cr3 = page_directory().cr3();
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
tss.esp = user_stack_address;
Kernel+LibPthread+LibC: Create secondary thread stacks in userspace Have pthread_create() allocate a stack and passing it to the kernel instead of this work happening in the kernel. The more of this we can do in userspace, the better. This patch also unexposes the raw create_thread() and exit_thread() syscalls since they are now only used by LibPthread anyway.
2019-11-17 16:28:17 +00:00
// NOTE: The stack needs to be 16-byte aligned.
thread->push_value_on_stack((u32)argument);
thread->push_value_on_stack(0);
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
thread->make_thread_specific_region({});
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
thread->set_state(Thread::State::Runnable);
Kernel: Make the create_thread() syscall return the new thread ID.
2019-07-14 08:17:58 +00:00
return thread->tid();
Kernel+LibC: Add a simple create_thread() syscall. It takes two parameters, a function pointer for the entry function, and a void* argument to be passed to that function on the new thread.
2019-03-23 21:59:08 +00:00
}
LibGUI+Kernel: Add a GLock class (userspace mutex.) It's basically a userspace port of the kernel's Lock class. Added gettid() and donate() syscalls to support the timeslice donation feature we already enjoyed in the kernel.
2019-03-25 12:03:49 +00:00
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
void Process::sys$exit_thread(void* exit_value)
Kernel+LibC: Add exit_thread() syscall.
2019-04-29 13:17:20 +00:00
{
Kernel: The exit_thread() syscall should unlock the big lock. Since exit_thread() never returns, it can't rely on the syscall trap handler to unlock the big lock before returning.
2019-04-29 13:56:25 +00:00
cli();
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
current->m_exit_value = exit_value;
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
current->set_should_die();
Kernel: The exit_thread() syscall should unlock the big lock. Since exit_thread() never returns, it can't rely on the syscall trap handler to unlock the big lock before returning.
2019-04-29 13:56:25 +00:00
big_lock().unlock_if_locked();
Kernel: Unwind kernel stacks before dying While executing in the kernel, a thread can acquire various resources that need cleanup, such as locks and references to RefCounted objects. This cleanup normally happens on the exit path, such as in destructors for various RAII guards. But we weren't calling those exit paths when killing threads that have been executing in the kernel, such as threads blocked on reading or sleeping, thus causing leaks. This commit changes how killing threads works. Now, instead of killing a thread directly, one is supposed to call thread->set_should_die(), which will unblock it and make it unwind the stack if it is blocked in the kernel. Then, just before returning to the userspace, the thread will automatically die.
2019-11-14 15:46:01 +00:00
current->die_if_needed();
Kernel+LibC: Add exit_thread() syscall.
2019-04-29 13:17:20 +00:00
ASSERT_NOT_REACHED();
}
Kernel+LibPthread: Implement pthread_detach()
2019-12-07 13:47:00 +00:00
int Process::sys$detach_thread(int tid)
{
Thread* thread = nullptr;
for_each_thread([&](auto& child_thread) {
if (child_thread.tid() == tid) {
thread = &child_thread;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!thread)
return -ESRCH;
if (!thread->is_joinable())
return -EINVAL;
thread->set_joinable(false);
return 0;
}
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
int Process::sys$join_thread(int tid, void** exit_value)
{
if (exit_value && !validate_write_typed(exit_value))
return -EFAULT;
Thread* thread = nullptr;
for_each_thread([&](auto& child_thread) {
if (child_thread.tid() == tid) {
thread = &child_thread;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!thread)
return -ESRCH;
if (thread == current)
return -EDEADLK;
if (thread->m_joinee == current)
return -EDEADLK;
ASSERT(thread->m_joiner != current);
if (thread->m_joiner)
return -EINVAL;
Kernel+LibPthread: pthread_create handles pthread_attr_t Add an initial implementation of pthread attributes for: * detach state (joinable, detached) * schedule params (just priority) * guard page size (as skeleton) (requires kernel support maybe?) * stack size and user-provided stack location (4 or 8 MB only, must be aligned) Add some tests too, to the thread test program. Also, LibC: Move pthread declarations to sys/types.h, where they belong.
2019-11-18 03:08:10 +00:00
if (!thread->is_joinable())
return -EINVAL;
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
Kernel: Move Thread::m_joinee_exit_value into the JoinBlocker There's no need for this to be a permanent Thread member. Just use a reference in the JoinBlocker instead.
2019-11-14 20:04:34 +00:00
void* joinee_exit_value = nullptr;
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
// FIXME: pthread_join() should not be interruptable. Enforce this somehow?
Kernel: Move Thread::m_joinee_exit_value into the JoinBlocker There's no need for this to be a permanent Thread member. Just use a reference in the JoinBlocker instead.
2019-11-14 20:04:34 +00:00
auto result = current->block<Thread::JoinBlocker>(*thread, joinee_exit_value);
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
(void)result;
// NOTE: 'thread' is very possibly deleted at this point. Clear it just to be safe.
thread = nullptr;
if (exit_value)
Kernel: Move Thread::m_joinee_exit_value into the JoinBlocker There's no need for this to be a permanent Thread member. Just use a reference in the JoinBlocker instead.
2019-11-14 20:04:34 +00:00
*exit_value = joinee_exit_value;
Kernel+LibPthread: Implement pthread_join() It's now possible to block until another thread in the same process has exited. We can also retrieve its exit value, which is whatever value it passed to pthread_exit(). :^)
2019-11-14 19:58:23 +00:00
return 0;
}
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
int Process::sys$set_thread_name(int tid, const char* buffer, int buffer_size)
{
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if (buffer_size < 0)
return -EINVAL;
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
if (!validate_read(buffer, buffer_size))
return -EFAULT;
const size_t max_thread_name_size = 64;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if (strnlen(buffer, (size_t)buffer_size) > max_thread_name_size)
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
return -EINVAL;
Thread* thread = nullptr;
for_each_thread([&](auto& child_thread) {
if (child_thread.tid() == tid) {
thread = &child_thread;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!thread)
return -ESRCH;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
thread->set_name({ buffer, (size_t)buffer_size });
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
return 0;
}
int Process::sys$get_thread_name(int tid, char* buffer, int buffer_size)
{
if (buffer_size <= 0)
return -EINVAL;
if (!validate_write(buffer, buffer_size))
return -EFAULT;
Thread* thread = nullptr;
for_each_thread([&](auto& child_thread) {
if (child_thread.tid() == tid) {
thread = &child_thread;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!thread)
return -ESRCH;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if (thread->name().length() >= (size_t)buffer_size)
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
return -ENAMETOOLONG;
strncpy(buffer, thread->name().characters(), buffer_size);
return 0;
}
LibGUI+Kernel: Add a GLock class (userspace mutex.) It's basically a userspace port of the kernel's Lock class. Added gettid() and donate() syscalls to support the timeslice donation feature we already enjoyed in the kernel.
2019-03-25 12:03:49 +00:00
int Process::sys$gettid()
{
return current->tid();
}
int Process::sys$donate(int tid)
{
if (tid < 0)
return -EINVAL;
InterruptDisabler disabler;
Thread* beneficiary = nullptr;
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
for_each_thread([&](Thread& thread) {
LibGUI+Kernel: Add a GLock class (userspace mutex.) It's basically a userspace port of the kernel's Lock class. Added gettid() and donate() syscalls to support the timeslice donation feature we already enjoyed in the kernel.
2019-03-25 12:03:49 +00:00
if (thread.tid() == tid) {
beneficiary = &thread;
Meta: Tweak .clang-format to not wrap braces after enums.
2019-06-07 15:13:23 +00:00
return IterationDecision::Break;
LibGUI+Kernel: Add a GLock class (userspace mutex.) It's basically a userspace port of the kernel's Lock class. Added gettid() and donate() syscalls to support the timeslice donation feature we already enjoyed in the kernel.
2019-03-25 12:03:49 +00:00
}
return IterationDecision::Continue;
});
if (!beneficiary)
return -ENOTHREAD;
Scheduler::donate_to(beneficiary, "sys$donate");
return 0;
}
Kernel+Userland: Add the rename() syscall along with a basic /bin/mv.
2019-04-07 21:35:26 +00:00
int Process::sys$rename(const char* oldpath, const char* newpath)
{
if (!validate_read_str(oldpath))
return -EFAULT;
if (!validate_read_str(newpath))
return -EFAULT;
Kernel: Rename Process::cwd_custody() to Process::current_directory(). ...and executable_custody() to just executable().
2019-05-30 18:23:50 +00:00
return VFS::the().rename(StringView(oldpath), StringView(newpath), current_directory());
Kernel+Userland: Add the rename() syscall along with a basic /bin/mv.
2019-04-07 21:35:26 +00:00
}
Kernel+LibC: Add stubs for POSIX shared memory API. Specifically shm_open() and shm_unlink(). This patch just adds stubs.
2019-04-08 21:44:12 +00:00
Kernel: More work towards POSIX SHM, also add ftruncate().
2019-04-08 23:10:00 +00:00
int Process::sys$ftruncate(int fd, off_t length)
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto* description = file_description(fd);
if (!description)
Kernel: More work towards POSIX SHM, also add ftruncate().
2019-04-08 23:10:00 +00:00
return -EBADF;
// FIXME: Check that fd is writable, otherwise EINVAL.
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
return description->truncate(length);
Kernel: More work towards POSIX SHM, also add ftruncate().
2019-04-08 23:10:00 +00:00
}
Kernel: Add a systrace() syscall and implement /bin/strace using it. Calling systrace(pid) gives you a file descriptor with a stream of the syscalls made by a peer process. The process must be owned by the same UID who calls systrace(). :^)
2019-04-22 16:44:45 +00:00
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
int Process::sys$watch_file(const char* path, int path_length)
{
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if (path_length < 0)
return -EINVAL;
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
if (!validate_read(path, path_length))
return -EFAULT;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
auto custody_or_error = VFS::the().resolve_path({ path, (size_t)path_length }, current_directory());
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
if (custody_or_error.is_error())
return custody_or_error.error();
auto& custody = custody_or_error.value();
auto& inode = custody->inode();
Kernel+FileManager: Disallow watch_file() in unsupported file systems Currently only Ext2FS and TmpFS supports InodeWatchers. We now fail with ENOTSUPP if watch_file() is called on e.g ProcFS. This fixes an issue with FileManager chewing up all the CPU when /proc was opened. Watchers don't keep the watched Inode open, and when they close, the watcher FD will EOF. Since nothing else kept /proc open in FileManager, the watchers created for it would EOF immediately, causing a refresh over and over. Fixes #879.
2019-12-15 18:33:39 +00:00
if (!inode.fs().supports_watchers())
return -ENOTSUP;
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
int fd = alloc_fd();
if (fd < 0)
return fd;
m_fds[fd].set(FileDescription::create(*InodeWatcher::create(inode)));
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
m_fds[fd].description->set_readable(true);
Kernel: Add a mechanism for listening for changes to an inode. The syscall is quite simple: int watch_file(const char* path, int path_length); It returns a file descriptor referring to a "InodeWatcher" object in the kernel. It becomes readable whenever something changes about the inode. Currently this is implemented by hooking the "metadata dirty bit" in Inode which isn't perfect, but it's a start. :^)
2019-07-22 18:01:11 +00:00
return fd;
}
Kernel: Add a systrace() syscall and implement /bin/strace using it. Calling systrace(pid) gives you a file descriptor with a stream of the syscalls made by a peer process. The process must be owned by the same UID who calls systrace(). :^)
2019-04-22 16:44:45 +00:00
int Process::sys$systrace(pid_t pid)
{
InterruptDisabler disabler;
auto* peer = Process::from_pid(pid);
if (!peer)
return -ESRCH;
if (peer->uid() != m_euid)
return -EACCES;
int fd = alloc_fd();
if (fd < 0)
return fd;
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
auto description = FileDescription::create(peer->ensure_tracer());
Kernel: read() and write() should fail with EBADF for wrong mode fd's It was previously possible to write to read-only file descriptors, and read from write-only file descriptors. All FileDescription objects now start out non-readable + non-writable, and whoever is creating them has to "manually" enable reading/writing by calling set_readable() and/or set_writable() on them.
2020-01-03 02:29:59 +00:00
description->set_readable(true);
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
m_fds[fd].set(move(description), 0);
Kernel: Add a systrace() syscall and implement /bin/strace using it. Calling systrace(pid) gives you a file descriptor with a stream of the syscalls made by a peer process. The process must be owned by the same UID who calls systrace(). :^)
2019-04-22 16:44:45 +00:00
return fd;
}
Kernel: Only allow superuser to halt() the system (#342) Following the discussion in #334, shutdown must also have root-only run permissions.
2019-07-19 11:08:26 +00:00
int Process::sys$halt()
{
if (!is_superuser())
return -EPERM;
dbgprintf("acquiring FS locks...\n");
FS::lock_all();
dbgprintf("syncing mounted filesystems...\n");
FS::sync();
dbgprintf("attempting system shutdown...\n");
IO::out16(0x604, 0x2000);
return ESUCCESS;
}
Kernel+Userland: Addd reboot syscall (#334) Rolling with the theme of adding a dialog to shutdown the machine, it is probably nice to have a way to reboot the machine without performing a full system powerdown. A reboot program has been added to `/bin/` as well as a corresponding `syscall` (SC_reboot). This syscall works by attempting to pulse the 8042 keyboard controller. Note that this is NOT supported on new machines, and should only be a fallback until we have proper ACPI support. The implementation causes a triple fault in QEMU, which then restarts the system. The filesystems are locked and synchronized before this occurs, so there shouldn't be any corruption etctera.
2019-07-19 07:58:12 +00:00
int Process::sys$reboot()
{
if (!is_superuser())
return -EPERM;
dbgprintf("acquiring FS locks...\n");
FS::lock_all();
dbgprintf("syncing mounted filesystems...\n");
FS::sync();
dbgprintf("attempting reboot via KB Controller...\n");
IO::out8(0x64, 0xFE);
return ESUCCESS;
}
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
int Process::sys$mount(const char* device_path, const char* mountpoint, const char* fstype)
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
{
Kernel: Some improvements to the mount syscall - You must now have superuser privileges to use mount(). - We now verify that the mount point is a valid path first, before trying to find a filesystem on the specified device. - Convert some dbgprintf() to dbg().
2019-08-02 17:03:50 +00:00
if (!is_superuser())
return -EPERM;
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
if (!validate_read_str(device_path) || !validate_read_str(mountpoint) || !validate_read_str(fstype))
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
return -EFAULT;
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
dbg() << "mount " << fstype << ": device " << device_path << " @ " << mountpoint;
Kernel: Some improvements to the mount syscall - You must now have superuser privileges to use mount(). - We now verify that the mount point is a valid path first, before trying to find a filesystem on the specified device. - Convert some dbgprintf() to dbg().
2019-08-02 17:03:50 +00:00
auto custody_or_error = VFS::the().resolve_path(mountpoint, current_directory());
if (custody_or_error.is_error())
return custody_or_error.error();
auto& mountpoint_custody = custody_or_error.value();
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
RefPtr<FS> fs { nullptr };
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
if (strcmp(fstype, "ext2") == 0 || strcmp(fstype, "Ext2FS") == 0) {
auto metadata_or_error = VFS::the().lookup_metadata(device_path, current_directory());
if (metadata_or_error.is_error())
return metadata_or_error.error();
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
auto major = metadata_or_error.value().major_device;
auto minor = metadata_or_error.value().minor_device;
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
Kernel: Move device lookup to Device class itself Previously, VFS stored a list of all devices, and devices had to register and unregister themselves with it. This cleans up things a bit.
2019-08-18 11:48:15 +00:00
auto* device = Device::get_device(major, minor);
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
if (!device) {
dbg() << "mount: device (" << major << "," << minor << ") not found";
return -ENODEV;
}
if (!device->is_disk_device()) {
dbg() << "mount: device (" << major << "," << minor << ") is not a DiskDevice";
return -ENODEV;
}
Kernel: mount() should fail if the provided device is not a disk device In the future, we should allow mounting any block device. At the moment there is too much filesystem code that depends on the underlying device being a DiskDevice.
2019-08-02 17:30:30 +00:00
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
auto& disk_device = static_cast<DiskDevice&>(*device);
Kernel: mount() should fail if the provided device is not a disk device In the future, we should allow mounting any block device. At the moment there is too much filesystem code that depends on the underlying device being a DiskDevice.
2019-08-02 17:30:30 +00:00
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
dbg() << "mount: attempting to mount device (" << major << "," << minor << ") on " << mountpoint;
fs = Ext2FS::create(disk_device);
} else if (strcmp(fstype, "proc") == 0 || strcmp(fstype, "ProcFS") == 0)
fs = ProcFS::create();
else if (strcmp(fstype, "devpts") == 0 || strcmp(fstype, "DevPtsFS") == 0)
fs = DevPtsFS::create();
else if (strcmp(fstype, "tmp") == 0 || strcmp(fstype, "TmpFS") == 0)
fs = TmpFS::create();
else
return -ENODEV;
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
if (!fs->initialize()) {
dbg() << "mount: failed to initialize " << fstype << " filesystem on " << device_path;
Kernel: mount() should fail if the provided device is not a disk device In the future, we should allow mounting any block device. At the moment there is too much filesystem code that depends on the underlying device being a DiskDevice.
2019-08-02 17:30:30 +00:00
return -ENODEV;
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
}
Kernel+LibC+Userland: Support mounting other kinds of filesystems
2019-08-15 16:13:56 +00:00
auto result = VFS::the().mount(fs.release_nonnull(), mountpoint_custody);
Kernel: Generalize VFS metadata lookup and use it in mount() and stat() Refactored VFS::stat() into VFS::lookup_metadata(), which can now be used for general VFS metadata lookup by path.
2019-08-02 17:23:23 +00:00
dbg() << "mount: successfully mounted " << device_path << " on " << mountpoint;
Kernel: Some improvements to the mount syscall - You must now have superuser privileges to use mount(). - We now verify that the mount point is a valid path first, before trying to find a filesystem on the specified device. - Convert some dbgprintf() to dbg().
2019-08-02 17:03:50 +00:00
return result;
Kernel: mount system call (#396) It is now possible to mount ext2 `DiskDevice` devices under Serenity on any folder in the root filesystem. Currently any user can do this with any permissions. There's a fair amount of assumptions made here too, that might not be too good, but can be worked on in the future. This is a good start to allow more dynamic operation under the OS itself. It is also currently impossible to unmount and such, and devices will fail to mount in Linux as the FS 'needs to be cleaned'. I'll work on getting `umount` done ASAP to rectify this (as well as working on less assumption-making in the mount syscall. We don't want to just be able to mount DiskDevices!). This could probably be fixed with some `-t` flag or something similar.
2019-08-02 13:18:47 +00:00
}
Kernel: Added unmount ability to VFS It is now possible to unmount file systems from the VFS via `umount`. It works via looking up the `fsid` of the filesystem from the `Inode`'s metatdata so I'm not sure how fragile it is. It seems to work for now though as something to get us going.
2019-08-11 13:56:39 +00:00
int Process::sys$umount(const char* mountpoint)
{
if (!is_superuser())
return -EPERM;
if (!validate_read_str(mountpoint))
return -EFAULT;
auto metadata_or_error = VFS::the().lookup_metadata(mountpoint, current_directory());
if (metadata_or_error.is_error())
return metadata_or_error.error();
Kernel: Do the umount() by the guest's root inode identifier It was previously possible to unmount a filesystem mounted on /mnt by doing e.g "umount /mnt/some/path".
2019-08-17 12:24:50 +00:00
auto guest_inode_id = metadata_or_error.value().inode;
return VFS::the().unmount(guest_inode_id);
Kernel: Added unmount ability to VFS It is now possible to unmount file systems from the VFS via `umount`. It works via looking up the `fsid` of the filesystem from the `Inode`'s metatdata so I'm not sure how fragile it is. It seems to work for now though as something to get us going.
2019-08-11 13:56:39 +00:00
}
Kernel: Add a systrace() syscall and implement /bin/strace using it. Calling systrace(pid) gives you a file descriptor with a stream of the syscalls made by a peer process. The process must be owned by the same UID who calls systrace(). :^)
2019-04-22 16:44:45 +00:00
ProcessTracer& Process::ensure_tracer()
{
if (!m_tracer)
m_tracer = ProcessTracer::create(m_pid);
return *m_tracer;
}
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
Kernel: Rename FileDescriptor to FileDescription. After reading a bunch of POSIX specs, I've learned that a file descriptor is the number that refers to a file description, not the description itself. So this patch renames FileDescriptor to FileDescription, and Process now has FileDescription* file_description(int fd).
2019-06-07 07:36:51 +00:00
void Process::FileDescriptionAndFlags::clear()
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description = nullptr;
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
flags = 0;
}
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 Process::FileDescriptionAndFlags::set(NonnullRefPtr<FileDescription>&& d, u32 f)
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
{
Kernel: Rename "descriptor" to "description" where appropriate. Now that FileDescription is called that, variables of that type should not be called "descriptor". This is kinda wordy but we'll get used to it.
2019-06-13 20:03:04 +00:00
description = move(d);
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
flags = f;
}
Kernel+Userland: Implement mknod() syscall and add a /bin/mknod program.
2019-05-03 20:59:58 +00:00
int Process::sys$mknod(const char* pathname, mode_t mode, dev_t dev)
{
if (!validate_read_str(pathname))
return -EFAULT;
Kernel: mknod() should not allow unprivileged users to create devices In fact, unless you are superuser, you may only create a regular file, a named pipe, or a local domain socket. Anything else should EPERM.
2020-01-02 01:36:12 +00:00
if (!is_superuser()) {
if (!is_regular_file(mode) && !is_fifo(mode) && !is_socket(mode))
return -EPERM;
}
Kernel: Make mknod() respect the process umask Otherwise the /bin/mknod command would create world-writable inodes by default (when run by superuser) which you probably don't want.
2020-01-02 01:39:25 +00:00
return VFS::the().mknod(StringView(pathname), mode & ~umask(), dev, current_directory());
Kernel+Userland: Implement mknod() syscall and add a /bin/mknod program.
2019-05-03 20:59:58 +00:00
}
Kernel+LibC: Add a dump_backtrace() syscall. This is very simple but already very useful. Now you're able to call to dump_backtrace() from anywhere userspace to get a nice symbolicated backtrace in the debugger output. :^)
2019-07-21 07:59:17 +00:00
int Process::sys$dump_backtrace()
{
dump_backtrace();
return 0;
}
Kernel+LibC: Add a dbgputch() syscall and use it for userspace dbgprintf(). The "stddbg" stream was a cute idea but we never ended up using it in practice, so let's simplify this and implement userspace dbgprintf() on top of a simple dbgputch() syscall instead. This makes debugging LibC startup a little bit easier. :^)
2019-07-21 17:45:31 +00:00
int Process::sys$dbgputch(u8 ch)
{
IO::out8(0xe9, ch);
return 0;
}
Kernel+LibC: Add a dbgputstr() syscall for sending strings to debug output. This is very handy for the DebugLogStream implementation, among others. :^)
2019-07-21 19:43:37 +00:00
int Process::sys$dbgputstr(const u8* characters, int length)
{
Kernel: Zero-length dbgputstr() should just return 0
2019-08-09 17:44:14 +00:00
if (!length)
return 0;
Kernel+LibC: Add a dbgputstr() syscall for sending strings to debug output. This is very handy for the DebugLogStream implementation, among others. :^)
2019-07-21 19:43:37 +00:00
if (!validate_read(characters, length))
return -EFAULT;
for (int i = 0; i < length; ++i)
IO::out8(0xe9, characters[i]);
return 0;
}
Kernel: Dump backtrace to debugger for DefaultSignalAction::DumpCore. This makes assertion failures generate backtraces again. Sorry to everyone who suffered from the lack of backtraces lately. :^) We share code with the /proc/PID/stack implementation. You can now get the current backtrace for a Thread via Thread::backtrace(), and all the traces for a Process via Process::backtrace().
2019-07-25 19:02:19 +00:00
Kernel: Use KBufferBuilder to build ProcFS files and backtraces This is not perfect as it uses a lot of VM, but since the buffers are supposed to be temporary it's not super terrible. This could be improved by giving back the unused VM to the kernel's RangeAllocator after finishing the buffer building.
2019-08-07 19:52:43 +00:00
KBuffer Process::backtrace(ProcessInspectionHandle& handle) const
Kernel: Dump backtrace to debugger for DefaultSignalAction::DumpCore. This makes assertion failures generate backtraces again. Sorry to everyone who suffered from the lack of backtraces lately. :^) We share code with the /proc/PID/stack implementation. You can now get the current backtrace for a Thread via Thread::backtrace(), and all the traces for a Process via Process::backtrace().
2019-07-25 19:02:19 +00:00
{
Kernel: Use KBufferBuilder to build ProcFS files and backtraces This is not perfect as it uses a lot of VM, but since the buffers are supposed to be temporary it's not super terrible. This could be improved by giving back the unused VM to the kernel's RangeAllocator after finishing the buffer building.
2019-08-07 19:52:43 +00:00
KBufferBuilder builder;
Kernel: Dump backtrace to debugger for DefaultSignalAction::DumpCore. This makes assertion failures generate backtraces again. Sorry to everyone who suffered from the lack of backtraces lately. :^) We share code with the /proc/PID/stack implementation. You can now get the current backtrace for a Thread via Thread::backtrace(), and all the traces for a Process via Process::backtrace().
2019-07-25 19:02:19 +00:00
for_each_thread([&](Thread& thread) {
Kernel: Allow setting thread names The main thread of each kernel/user process will take the name of the process. Extra threads will get a fancy new name "ProcessName[<tid>]". Thread backtraces now list the thread name in addtion to tid. Add the thread name to /proc/all (should it get its own proc file?). Add two new syscalls, set_thread_name and get_thread_name.
2019-12-07 19:45:26 +00:00
builder.appendf("Thread %d (%s):\n", thread.tid(), thread.name().characters());
Kernel: Dump backtrace to debugger for DefaultSignalAction::DumpCore. This makes assertion failures generate backtraces again. Sorry to everyone who suffered from the lack of backtraces lately. :^) We share code with the /proc/PID/stack implementation. You can now get the current backtrace for a Thread via Thread::backtrace(), and all the traces for a Process via Process::backtrace().
2019-07-25 19:02:19 +00:00
builder.append(thread.backtrace(handle));
return IterationDecision::Continue;
});
Kernel: Use KBufferBuilder to build ProcFS files and backtraces This is not perfect as it uses a lot of VM, but since the buffers are supposed to be temporary it's not super terrible. This could be improved by giving back the unused VM to the kernel's RangeAllocator after finishing the buffer building.
2019-08-07 19:52:43 +00:00
return builder.build();
Kernel: Dump backtrace to debugger for DefaultSignalAction::DumpCore. This makes assertion failures generate backtraces again. Sorry to everyone who suffered from the lack of backtraces lately. :^) We share code with the /proc/PID/stack implementation. You can now get the current backtrace for a Thread via Thread::backtrace(), and all the traces for a Process via Process::backtrace().
2019-07-25 19:02:19 +00:00
}
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
int Process::sys$set_process_icon(int icon_id)
{
LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(icon_id);
if (it == shared_buffers().resource().end())
return -EINVAL;
auto& shared_buffer = *(*it).value;
if (!shared_buffer.is_shared_with(m_pid))
return -EPERM;
m_icon_id = icon_id;
return 0;
}
Kernel+LibC: Add get_process_name() syscall It does exactly what it sounds like: int get_process_name(char* buffer, int buffer_size);
2019-08-15 18:55:10 +00:00
int Process::sys$get_process_name(char* buffer, int buffer_size)
{
if (buffer_size <= 0)
return -EINVAL;
if (!validate_write(buffer, buffer_size))
return -EFAULT;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
if (m_name.length() >= (size_t)buffer_size)
Kernel+LibC: Add get_process_name() syscall It does exactly what it sounds like: int get_process_name(char* buffer, int buffer_size);
2019-08-15 18:55:10 +00:00
return -ENAMETOOLONG;
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 16:45:40 +00:00
strncpy(buffer, m_name.characters(), (size_t)buffer_size);
Kernel+LibC: Add get_process_name() syscall It does exactly what it sounds like: int get_process_name(char* buffer, int buffer_size);
2019-08-15 18:55:10 +00:00
return 0;
}
Kernel: Add a Linux-style getrandom syscall The way it gets the entropy and blasts it to the buffer is pretty ugly IMHO, but it does work for now. (It should be replaced, by not truncating a u32.) It implements an (unused for now) flags argument, like Linux but instead of OpenBSD's. This is in case we want to distinguish between entropy sources or any other reason and have to implement a new syscall later. Of course, learn from Linux's struggles with entropy sourcing too.
2019-10-13 14:41:55 +00:00
// We don't use the flag yet, but we could use it for distinguishing
// random source like Linux, unlike the OpenBSD equivalent. However, if we
// do, we should be able of the caveats that Linux has dealt with.
int Process::sys$getrandom(void* buffer, size_t buffer_size, unsigned int flags __attribute__((unused)))
{
if (buffer_size <= 0)
return -EINVAL;
if (!validate_write(buffer, buffer_size))
return -EFAULT;
Kernel: Use word-sized entropy as much as possible in syscall
2019-10-13 15:55:58 +00:00
Kernel: Add a more expressive API for getting random bytes We now have these API's in <Kernel/Random.h>: - get_fast_random_bytes(u8* buffer, size_t buffer_size) - get_good_random_bytes(u8* buffer, size_t buffer_size) - get_fast_random<T>() - get_good_random<T>() Internally they both use x86 RDRAND if available, otherwise they fall back to the same LCG we had in RandomDevice all along. The main purpose of this patch is to give kernel code a way to better express its needs for random data. Randomness is something that will require a lot more work, but this is hopefully a step in the right direction.
2020-01-03 11:36:30 +00:00
get_good_random_bytes((u8*)buffer, buffer_size);
Kernel: Add a Linux-style getrandom syscall The way it gets the entropy and blasts it to the buffer is pretty ugly IMHO, but it does work for now. (It should be replaced, by not truncating a u32.) It implements an (unused for now) flags argument, like Linux but instead of OpenBSD's. This is in case we want to distinguish between entropy sources or any other reason and have to implement a new syscall later. Of course, learn from Linux's struggles with entropy sourcing too.
2019-10-13 14:41:55 +00:00
return 0;
}
Kernel+LibC: Implement clock_gettime() and clock_nanosleep() Only the CLOCK_MONOTONIC clock is supported at the moment, and it only has millisecond precision. :^)
2019-11-02 18:34:06 +00:00
Kernel: Implement AltGr key support
2019-12-31 12:37:38 +00:00
int Process::sys$setkeymap(const Syscall::SC_setkeymap_params* params)
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
{
if (!is_superuser())
return -EPERM;
Kernel: Implement AltGr key support
2019-12-31 12:37:38 +00:00
if (!validate_read_typed(params))
return -EFAULT;
if (!validate_read(params->map, 0x80))
return -EFAULT;
if (!validate_read(params->shift_map, 0x80))
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
return -EFAULT;
Kernel: Implement AltGr key support
2019-12-31 12:37:38 +00:00
if (!validate_read(params->alt_map, 0x80))
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
return -EFAULT;
Kernel: Implement AltGr key support
2019-12-31 12:37:38 +00:00
if (!validate_read(params->altgr_map, 0x80))
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
return -EFAULT;
Kernel: Implement AltGr key support
2019-12-31 12:37:38 +00:00
KeyboardDevice::the().set_maps(params->map, params->shift_map, params->alt_map, params->altgr_map);
Kernel: Implement the setkeymap() syscall.
2019-11-23 07:48:07 +00:00
return 0;
}
Kernel+LibC: Implement clock_gettime() and clock_nanosleep() Only the CLOCK_MONOTONIC clock is supported at the moment, and it only has millisecond precision. :^)
2019-11-02 18:34:06 +00:00
int Process::sys$clock_gettime(clockid_t clock_id, timespec* ts)
{
if (!validate_write_typed(ts))
return -EFAULT;
switch (clock_id) {
case CLOCK_MONOTONIC:
ts->tv_sec = g_uptime / TICKS_PER_SECOND;
ts->tv_nsec = (g_uptime % TICKS_PER_SECOND) * 1000000;
break;
default:
return -EINVAL;
}
return 0;
}
int Process::sys$clock_nanosleep(const Syscall::SC_clock_nanosleep_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
auto& [clock_id, flags, requested_sleep, remaining_sleep] = *params;
if (requested_sleep && !validate_read_typed(requested_sleep))
Kernel+LibC: Implement clock_gettime() and clock_nanosleep() Only the CLOCK_MONOTONIC clock is supported at the moment, and it only has millisecond precision. :^)
2019-11-02 18:34:06 +00:00
return -EFAULT;
Kernel: Use C++ structured bindings to bind syscall parameters Some syscalls have to pass parameters through a struct, since we can only fit 3 parameters with our calling convention. This patch makes use of C++ structured binding to clean up the places where we expand those parameters structs into local variables.
2019-11-10 14:32:59 +00:00
if (remaining_sleep && !validate_write_typed(remaining_sleep))
Kernel+LibC: Implement clock_gettime() and clock_nanosleep() Only the CLOCK_MONOTONIC clock is supported at the moment, and it only has millisecond precision. :^)
2019-11-02 18:34:06 +00:00
return -EFAULT;
bool is_absolute = flags & TIMER_ABSTIME;
switch (clock_id) {
case CLOCK_MONOTONIC: {
u64 wakeup_time;
if (is_absolute) {
u64 time_to_wake = (requested_sleep->tv_sec * 1000 + requested_sleep->tv_nsec / 1000000);
wakeup_time = current->sleep_until(time_to_wake);
} else {
u32 ticks_to_sleep = (requested_sleep->tv_sec * 1000 + requested_sleep->tv_nsec / 1000000);
if (!ticks_to_sleep)
return 0;
wakeup_time = current->sleep(ticks_to_sleep);
}
if (wakeup_time > g_uptime) {
u32 ticks_left = wakeup_time - g_uptime;
if (!is_absolute && remaining_sleep) {
remaining_sleep->tv_sec = ticks_left / TICKS_PER_SECOND;
ticks_left -= remaining_sleep->tv_sec * TICKS_PER_SECOND;
remaining_sleep->tv_nsec = ticks_left * 1000000;
}
return -EINTR;
}
return 0;
}
default:
return -EINVAL;
}
}
Kernel: Use a lookup table for syscalls Instead of the big ugly switch statement, build a lookup table using the syscall enumeration macro. This greatly simplifies the syscall implementation. :^)
2019-11-09 21:18:16 +00:00
int Process::sys$sync()
{
VFS::the().sync();
return 0;
}
int Process::sys$putch(char ch)
{
Console::the().put_char(ch);
return 0;
}
int Process::sys$yield()
{
Kernel: Release the big process lock while yielding in sys$yield() Otherwise, a thread calling sched_yield() will prevent other threads in that process from entering the kernel.
2019-11-16 11:18:59 +00:00
current->yield_without_holding_big_lock();
return 0;
Kernel: Use a lookup table for syscalls Instead of the big ugly switch statement, build a lookup table using the syscall enumeration macro. This greatly simplifies the syscall implementation. :^)
2019-11-09 21:18:16 +00:00
}
int Process::sys$beep()
{
Kernel: Move PC speaker beep timing logic from scheduler to the syscall I don't know why I put this in the scheduler to begin with.. the caller can just block until the beeping is finished.
2019-12-26 21:31:26 +00:00
PCSpeaker::tone_on(440);
u64 wakeup_time = current->sleep(100);
PCSpeaker::tone_off();
if (wakeup_time > g_uptime)
return -EINTR;
Kernel: Use a lookup table for syscalls Instead of the big ugly switch statement, build a lookup table using the syscall enumeration macro. This greatly simplifies the syscall implementation. :^)
2019-11-09 21:18:16 +00:00
return 0;
}
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
int Process::sys$module_load(const char* path, size_t path_length)
{
if (!is_superuser())
return -EPERM;
if (!validate_read(path, path_length))
return -EFAULT;
auto description_or_error = VFS::the().open(path, 0, 0, current_directory());
if (description_or_error.is_error())
return description_or_error.error();
auto& description = description_or_error.value();
auto payload = description->read_entire_file();
auto storage = KBuffer::create_with_size(payload.size());
memcpy(storage.data(), payload.data(), payload.size());
payload.clear();
// FIXME: ELFImage should really be taking a size argument as well...
auto elf_image = make<ELFImage>(storage.data());
if (!elf_image->parse())
return -ENOEXEC;
HashMap<String, u8*> section_storage_by_name;
auto module = make<Module>();
elf_image->for_each_section_of_type(SHT_PROGBITS, [&](const ELFImage::Section& section) {
Kernel: Unbreak module loading (broke with NX bit changes) Modules are now mapped fully RWX. This can definitely be improved, but at least it unbreaks the feature for now.
2020-01-03 02:44:55 +00:00
auto section_storage = KBuffer::copy(section.raw_data(), section.size(), Region::Access::Read | Region::Access::Write | Region::Access::Execute);
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
section_storage_by_name.set(section.name(), section_storage.data());
module->sections.append(move(section_storage));
return IterationDecision::Continue;
});
Kernel: Fail module loading if any symbols can not be resolved
2019-12-24 03:09:18 +00:00
bool missing_symbols = false;
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
elf_image->for_each_section_of_type(SHT_PROGBITS, [&](const ELFImage::Section& section) {
auto* section_storage = section_storage_by_name.get(section.name()).value_or(nullptr);
ASSERT(section_storage);
section.relocations().for_each_relocation([&](const ELFImage::Relocation& relocation) {
auto& patch_ptr = *reinterpret_cast<ptrdiff_t*>(section_storage + relocation.offset());
switch (relocation.type()) {
case R_386_PC32: {
// PC-relative relocation
dbg() << "PC-relative relocation: " << relocation.symbol().name();
Kernel: Allow modules to link against anything in kernel.map :^) We now use the symbols from kernel.map to link modules as they are loaded into the kernel. This is pretty fricken cool!
2019-11-28 20:30:20 +00:00
u32 symbol_address = address_for_kernel_symbol(relocation.symbol().name());
Kernel: Fail module loading if any symbols can not be resolved
2019-12-24 03:09:18 +00:00
if (symbol_address == 0)
missing_symbols = true;
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
dbg() << " Symbol address: " << (void*)symbol_address;
ptrdiff_t relative_offset = (char*)symbol_address - ((char*)&patch_ptr + 4);
patch_ptr = relative_offset;
break;
}
case R_386_32: // Absolute relocation
dbg() << "Absolute relocation: '" << relocation.symbol().name() << "' value:" << relocation.symbol().value() << ", index:" << relocation.symbol_index();
Kernel: Allow modules to link against anything in kernel.map :^) We now use the symbols from kernel.map to link modules as they are loaded into the kernel. This is pretty fricken cool!
2019-11-28 20:30:20 +00:00
if (relocation.symbol().bind() == STB_LOCAL) {
auto* section_storage_containing_symbol = section_storage_by_name.get(relocation.symbol().section().name()).value_or(nullptr);
ASSERT(section_storage_containing_symbol);
Kernel: Fail module loading if any symbols can not be resolved
2019-12-24 03:09:18 +00:00
u32 symbol_address = (ptrdiff_t)(section_storage_containing_symbol + relocation.symbol().value());
if (symbol_address == 0)
missing_symbols = true;
dbg() << " Symbol address: " << (void*)symbol_address;
patch_ptr += symbol_address;
Kernel: Allow modules to link against anything in kernel.map :^) We now use the symbols from kernel.map to link modules as they are loaded into the kernel. This is pretty fricken cool!
2019-11-28 20:30:20 +00:00
} else if (relocation.symbol().bind() == STB_GLOBAL) {
Kernel: Fail module loading if any symbols can not be resolved
2019-12-24 03:09:18 +00:00
u32 symbol_address = address_for_kernel_symbol(relocation.symbol().name());
if (symbol_address == 0)
missing_symbols = true;
dbg() << " Symbol address: " << (void*)symbol_address;
patch_ptr += symbol_address;
Kernel: Allow modules to link against anything in kernel.map :^) We now use the symbols from kernel.map to link modules as they are loaded into the kernel. This is pretty fricken cool!
2019-11-28 20:30:20 +00:00
} else {
ASSERT_NOT_REACHED();
}
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
break;
}
return IterationDecision::Continue;
});
return IterationDecision::Continue;
});
Kernel: Fail module loading if any symbols can not be resolved
2019-12-24 03:09:18 +00:00
if (missing_symbols)
return -ENOENT;
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
auto* text_base = section_storage_by_name.get(".text").value_or(nullptr);
if (!text_base) {
dbg() << "No .text section found in module!";
return -EINVAL;
}
elf_image->for_each_symbol([&](const ELFImage::Symbol& symbol) {
dbg() << " - " << symbol.type() << " '" << symbol.name() << "' @ " << (void*)symbol.value() << ", size=" << symbol.size();
if (!strcmp(symbol.name(), "module_init")) {
Kernel: Implement basic module unloading :^) Kernel modules can now be unloaded via a syscall. They get a chance to run some code of course. Before deallocating them, we call their "module_fini" symbol.
2019-11-28 20:07:22 +00:00
module->module_init = (ModuleInitPtr)(text_base + symbol.value());
} else if (!strcmp(symbol.name(), "module_fini")) {
module->module_fini = (ModuleFiniPtr)(text_base + symbol.value());
Kernel: Have modules export their name in a "module_name" string This will show up in /proc/modules, and is also the name you can pass to the module_unload() syscall for unloading the module.
2019-11-29 20:31:17 +00:00
} else if (!strcmp(symbol.name(), "module_name")) {
const u8* storage = section_storage_by_name.get(symbol.section().name()).value_or(nullptr);
if (storage)
module->name = String((const char*)(storage + symbol.value()));
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
}
return IterationDecision::Continue;
});
Kernel: Implement basic module unloading :^) Kernel modules can now be unloaded via a syscall. They get a chance to run some code of course. Before deallocating them, we call their "module_fini" symbol.
2019-11-28 20:07:22 +00:00
if (!module->module_init)
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
return -EINVAL;
Kernel: Disallow loading a module twice without explicitly unloading it This ensures that a module has the chance to run its cleanup functions before it's taken out of service.
2019-12-24 00:40:26 +00:00
if (g_modules->contains(module->name)) {
dbg() << "a module with the name " << module->name << " is already loaded; please unload it first";
return -EEXIST;
}
Kernel: Implement basic module unloading :^) Kernel modules can now be unloaded via a syscall. They get a chance to run some code of course. Before deallocating them, we call their "module_fini" symbol.
2019-11-28 20:07:22 +00:00
module->module_init();
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
auto name = module->name;
g_modules->set(name, move(module));
return 0;
}
int Process::sys$module_unload(const char* name, size_t name_length)
{
if (!is_superuser())
return -EPERM;
if (!validate_read(name, name_length))
return -EFAULT;
Kernel: Implement basic module unloading :^) Kernel modules can now be unloaded via a syscall. They get a chance to run some code of course. Before deallocating them, we call their "module_fini" symbol.
2019-11-28 20:07:22 +00:00
auto it = g_modules->find(name);
if (it == g_modules->end())
return -ENOENT;
if (it->value->module_fini)
it->value->module_fini();
g_modules->remove(it);
Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module.
2019-11-28 19:59:11 +00:00
return 0;
}
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
int Process::sys$profiling_enable(pid_t pid)
{
InterruptDisabler disabler;
auto* process = Process::from_pid(pid);
if (!process)
return -ESRCH;
if (!is_superuser() && process->uid() != m_uid)
return -EPERM;
Profiling::start(*process);
process->set_profiling(true);
return 0;
}
int Process::sys$profiling_disable(pid_t pid)
{
InterruptDisabler disabler;
auto* process = Process::from_pid(pid);
if (!process)
return -ESRCH;
if (!is_superuser() && process->uid() != m_uid)
return -EPERM;
process->set_profiling(false);
Profiling::stop();
return 0;
}
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +00:00
void* Process::sys$get_kernel_info_page()
{
Kernel: Make sure the kernel info page is read-only for userspace To enforce this, we create two separate mappings of the same underlying physical page. A writable mapping for the kernel, and a read-only one for userspace (the one returned by sys$get_kernel_info_page.)
2019-12-15 21:21:28 +00:00
return s_info_page_address_for_userspace.as_ptr();
Kernel+LibC: Publish a "kernel info page" and use it for gettimeofday() This patch adds a single "kernel info page" that is mappable read-only by any process and contains the current time of day. This is then used to implement a version of gettimeofday() that doesn't have to make a syscall. To protect against race condition issues, the info page also has a serial number which is incremented whenever the kernel updates the contents of the page. Make sure to verify that the serial number is the same before and after reading the information you want from the page.
2019-12-15 20:29:26 +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
Thread& Process::any_thread()
{
Thread* found_thread = nullptr;
for_each_thread([&](auto& thread) {
found_thread = &thread;
return IterationDecision::Break;
});
ASSERT(found_thread);
return *found_thread;
}
Kernel+LibPthread+LibC: Add a naive futex and use it for pthread_cond_t This patch implements a simple version of the futex (fast userspace mutex) API in the kernel and uses it to make the pthread_cond_t API's block instead of busily sched_yield(). An arbitrary userspace address is passed to the kernel as a "token" that identifies the futex and you can then FUTEX_WAIT and FUTEX_WAKE that specific userspace address. FUTEX_WAIT corresponds to pthread_cond_wait() and FUTEX_WAKE is used for pthread_cond_signal() and pthread_cond_broadcast(). I'm pretty sure I'm missing something in this implementation, but it's hopefully okay for a start. :^)
2019-12-22 20:29:47 +00:00
WaitQueue& Process::futex_queue(i32* userspace_address)
{
auto& queue = m_futex_queues.ensure((u32)userspace_address);
if (!queue)
queue = make<WaitQueue>();
return *queue;
}
int Process::sys$futex(const Syscall::SC_futex_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
auto& [userspace_address, futex_op, value, timeout] = *params;
if (!validate_read_typed(userspace_address))
return -EFAULT;
if (timeout && !validate_read_typed(timeout))
return -EFAULT;
switch (futex_op) {
case FUTEX_WAIT:
if (*userspace_address != value)
return -EAGAIN;
// FIXME: This is supposed to be interruptible by a signal, but right now WaitQueue cannot be interrupted.
// FIXME: Support timeout!
current->wait_on(futex_queue(userspace_address));
break;
case FUTEX_WAKE:
if (value == 0)
return 0;
if (value == 1) {
futex_queue(userspace_address).wake_one();
} else {
// FIXME: Wake exactly (value) waiters.
futex_queue(userspace_address).wake_all();
}
break;
}
return 0;
}
Kernel: Add a basic thread boosting mechanism This patch introduces a syscall: int set_thread_boost(int tid, int amount) You can use this to add a permanent boost value to the effective thread priority of any thread with your UID (or any thread in the system if you are the superuser.) This is quite crude, but opens up some interesting opportunities. :^)
2019-12-30 18:23:13 +00:00
int Process::sys$set_thread_boost(int tid, int amount)
{
if (amount < 0 || amount > 20)
return -EINVAL;
InterruptDisabler disabler;
auto* thread = Thread::from_tid(tid);
if (!thread)
return -ESRCH;
if (thread->state() == Thread::State::Dead || thread->state() == Thread::State::Dying)
return -ESRCH;
if (!is_superuser() && thread->process().uid() != euid())
return -EPERM;
thread->set_priority_boost(amount);
return 0;
}
Kernel: Also add a process boosting mechanism Let's also have set_process_boost() for giving all threads in a process the same boost.
2019-12-30 19:10:00 +00:00
int Process::sys$set_process_boost(pid_t pid, int amount)
{
if (amount < 0 || amount > 20)
return -EINVAL;
InterruptDisabler disabler;
auto* process = Process::from_pid(pid);
if (!process || process->is_dead())
return -ESRCH;
if (!is_superuser() && process->uid() != euid())
return -EPERM;
process->m_priority_boost = amount;
return 0;
}
Reference in a new issue Copy permalink