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

2688 lines
79 KiB
C++
Raw Normal View History

Kernel: Get rid of Kernel/types.h, separate LinearAddress/PhysicalAddress.
2019-04-06 12:29:29 +00:00
#include <AK/Types.h>
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
#include "Process.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
#include "kmalloc.h"
#include "StdLib.h"
#include "i386.h"
Kernel: Move FIFO into FileSystem/ and Socket+LocalSocket into Net/.
2019-04-06 18:29:48 +00:00
#include <Kernel/FileSystem/FileDescriptor.h>
Kernel: Move FS-related files into Kernel/FileSystem/
2019-04-03 10:25:24 +00:00
#include <Kernel/FileSystem/VirtualFileSystem.h>
Kernel: Move devices into Kernel/Devices/.
2019-04-03 10:36:40 +00:00
#include <Kernel/Devices/NullDevice.h>
Kernel: Move ELF-related files into Kernel/ELF/.
2019-04-03 10:30:04 +00:00
#include <Kernel/ELF/ELFLoader.h>
Kernel: Move VM-related files into Kernel/VM/. Also break MemoryManager.{cpp,h} into one file per class.
2019-04-03 13:13:07 +00:00
#include <Kernel/VM/MemoryManager.h>
Add a "sleep" syscall that sleeps for N seconds.
2018-10-25 11:53:49 +00:00
#include "i8253.h"
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
#include "RTC.h"
Import a simple text editor I started working on.
2018-12-03 23:27:16 +00:00
#include <AK/StdLibExtras.h>
Add strsignal() and improve sharing signal numbers between LibC and kernel.
2018-11-06 14:45:16 +00:00
#include <LibC/signal_numbers.h>
Remove some unused errno.h duplicates.
2019-01-22 00:12:53 +00:00
#include <LibC/errno_numbers.h>
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
#include "Syscall.h"
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
#include "Scheduler.h"
Kernel: Move FIFO into FileSystem/ and Socket+LocalSocket into Net/.
2019-04-06 18:29:48 +00:00
#include <Kernel/FileSystem/FIFO.h>
Move kernel symbolication code out of init.cpp and into its own KSym files. Also use a simple array of { dword, const char* } for the KSyms and put the whole shebang in kmalloc_eternal() memory. This was a fugly source of kmalloc perma-frag.
2018-12-24 21:59:10 +00:00
#include "KSyms.h"
Kernel: Move FIFO into FileSystem/ and Socket+LocalSocket into Net/.
2019-04-06 18:29:48 +00:00
#include <Kernel/Net/Socket.h>
Kernel: Move TTY-related files into Kernel/TTY/.
2019-04-03 10:28:45 +00:00
#include <Kernel/TTY/MasterPTY.h>
Kernel: Move ELF-related files into Kernel/ELF/.
2019-04-03 10:30:04 +00:00
#include <Kernel/ELF/exec_elf.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: Yet more work on bringing up POSIX SHM.
2019-04-09 00:37:05 +00:00
#include <Kernel/SharedMemory.h>
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
#include <Kernel/ProcessTracer.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: 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
#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
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;
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +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::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
{
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;
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;
Kernel: Reduce kmallocing in all_processes() and all_pids().
2019-04-15 22:37:35 +00:00
pids.ensure_capacity(g_processes->size_slow());
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
for (auto* process = g_processes->head(); process; process = process->next())
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
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;
Kernel: Reduce kmallocing in all_processes() and all_pids().
2019-04-15 22:37:35 +00:00
processes.ensure_capacity(g_processes->size_slow());
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
for (auto* process = g_processes->head(); process; process = process->next())
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
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
{
return m_gids.contains(gid);
}
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
Range Process::allocate_range(LinearAddress laddr, 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: 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
laddr.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: 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
if (laddr.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);
return page_directory().range_allocator().allocate_specific(laddr, 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: 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
Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name, bool is_readable, bool is_writable, bool commit)
{
auto range = allocate_range(laddr, size);
if (!range.is_valid())
return nullptr;
Kernel: Let Region keep a Range internally.
2019-05-17 02:32:08 +00:00
m_regions.append(adopt(*new Region(range, move(name), is_readable, is_writable)));
Yet more coding style fixes.
2018-12-03 00:38:22 +00:00
MM.map_region(*this, *m_regions.last());
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)
m_regions.last()->commit();
Add Regions concept to Task.
2018-10-18 12:53:00 +00:00
return m_regions.last().ptr();
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
}
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
Region* Process::allocate_file_backed_region(LinearAddress laddr, size_t size, RetainPtr<Inode>&& inode, String&& name, bool is_readable, bool is_writable)
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: 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
auto range = allocate_range(laddr, size);
if (!range.is_valid())
return nullptr;
Kernel: Let Region keep a Range internally.
2019-05-17 02:32:08 +00:00
m_regions.append(adopt(*new Region(range, move(inode), move(name), is_readable, is_writable)));
Yet more coding style fixes.
2018-12-03 00:38:22 +00:00
MM.map_region(*this, *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
return m_regions.last().ptr();
}
Convert more RetainPtr use to Retained.
2019-02-25 15:04:08 +00:00
Region* Process::allocate_region_with_vmo(LinearAddress laddr, size_t size, Retained<VMObject>&& vmo, size_t offset_in_vmo, String&& name, bool is_readable, bool is_writable)
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: 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
auto range = allocate_range(laddr, size);
if (!range.is_valid())
return nullptr;
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
offset_in_vmo &= PAGE_MASK;
Kernel: Let Region keep a Range internally.
2019-05-17 02:32:08 +00:00
m_regions.append(adopt(*new Region(range, move(vmo), offset_in_vmo, move(name), is_readable, is_writable)));
Yet more coding style fixes.
2018-12-03 00:38:22 +00:00
MM.map_region(*this, *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
return m_regions.last().ptr();
}
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) {
AK: Improve smart pointer ergonomics a bit.
2019-04-14 00:36:06 +00:00
if (m_regions[i] == &region) {
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
page_directory().range_allocator().deallocate({ region.laddr(), region.size() });
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
MM.unmap_region(region);
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
m_regions.remove(i);
return true;
}
}
return false;
}
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
Region* Process::region_from_range(LinearAddress laddr, size_t size)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
{
Kernel: munmap() should round up to nearest page size, just like mmap(). The mismatch between the two was causing some trouble if you'd mmap e.g 1KB and then try to munmap() it. The kernel would whine that it couldn't find any such mapping (because mmap() actually rounded the 1KB to a 4KB page.)
2019-02-17 07:32:08 +00:00
size = PAGE_ROUND_UP(size);
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
for (auto& region : m_regions) {
Kernel: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
if (region->laddr() == laddr && region->size() == size)
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
return region.ptr();
}
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;
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
auto* region = region_from_range(LinearAddress((dword)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: 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;
}
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;
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 (params->name && !validate_read_str(params->name))
return (void*)-EFAULT;
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* addr = (void*)params->addr;
size_t size = params->size;
int prot = params->prot;
int flags = params->flags;
int fd = params->fd;
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
off_t offset = params->offset;
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
const char* name = params->name;
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;
Kernel: Allow mmap() with a size that's not a multiple of page size. We just round it up to the next multiple of page size anyway.
2019-02-09 07:44:46 +00:00
if ((dword)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;
if (flags & MAP_ANONYMOUS) {
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
auto* region = allocate_region(LinearAddress((dword)addr), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false);
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 (!region)
return (void*)-ENOMEM;
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
if (flags & MAP_SHARED)
region->set_shared(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: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
return region->laddr().as_ptr();
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 (offset & ~PAGE_MASK)
return (void*)-EINVAL;
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return (void*)-EBADF;
Kernel: Make ProcessTracer inherit from File.
2019-04-28 13:02:55 +00:00
auto region_or_error = descriptor->mmap(*this, LinearAddress((dword)addr), offset, size, prot);
if (region_or_error.is_error())
return (void*)(int)region_or_error.error();
auto region = region_or_error.value();
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
if (flags & MAP_SHARED)
region->set_shared(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: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
return region->laddr().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
{
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
auto* region = region_from_range(LinearAddress((dword)addr), size);
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +00:00
if (!region)
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
return -EINVAL;
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
if (!deallocate_region(*region))
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
return -EINVAL;
Add simplified mmap() and munmap() syscalls.
2018-10-24 07:48:24 +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$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);
if (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
}
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
Process* Process::fork(RegisterDump& regs)
{
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
auto* child = new Process(String(m_name), m_uid, m_gid, m_pid, m_ring, m_cwd.copy_ref(), m_executable.copy_ref(), 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
if (!child)
return nullptr;
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
Compat work towards porting vim.
2019-02-26 14:57:59 +00:00
dbgprintf("fork: cloning Region{%p} \"%s\" L%x\n", region.ptr(), region->name().characters(), region->laddr().get());
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
auto cloned_region = region->clone();
child->m_regions.append(move(cloned_region));
Yet more coding style fixes.
2018-12-03 00:38:22 +00:00
MM.map_region(*child, *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: Clone Process::m_gids on fork() and hook up any framebuffer region.
2019-01-21 00:49:30 +00:00
for (auto gid : m_gids)
child->m_gids.set(gid);
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& child_tss = child->main_thread().m_tss;
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
child->main_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_t Process::sys$fork(RegisterDump& regs)
{
auto* child = fork(regs);
ASSERT(child);
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");
for_each_thread([] (Thread& thread) {
dbgprintf("Thread{%p}: TID=%d, PID=%d\n", &thread, thread.tid(), thread.pid());
return IterationDecision::Continue;
});
ASSERT(thread_count() == 1);
ASSERT_NOT_REACHED();
}
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
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;
Kernel: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
auto result = VFS::the().open(path.view(), 0, 0, cwd_inode());
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
if (result.is_error())
return result.error();
auto descriptor = result.value();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
if (!descriptor->metadata().may_execute(m_euid, m_gids))
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
return -EACCES;
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
if (!descriptor->metadata().size) {
return -ENOTIMPL;
}
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
dword 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: 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
m_page_directory = PageDirectory::create_for_userspace();
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
mmap all the font files! Font now uses the same in-memory format as the font files we have on disk. This allows us to simply mmap() the font files and not use any additional memory for them. Very cool! :^) Hacking on this exposed a bug in file-backed VMObjects where the first client to instantiate a VMObject for a specific inode also got to decide its size. Since file-backed VMObjects always have the same size as the underlying file, this made no sense, so I removed the ability to even set a size in that case.
2019-02-05 05:43:33 +00:00
auto vmo = VMObject::create_file_backed(descriptor->inode());
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
#if 0
// FIXME: I would like to do this, but it would instantiate all the damn inodes.
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
vmo->set_name(descriptor->absolute_path());
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
#else
vmo->set_name("ELF image");
#endif
Kernel: Drop the "helper" region after ELF load is finished. The individual segment mappings will keep the VMObject alive.
2019-02-10 11:42:54 +00:00
RetainPtr<Region> region = allocate_region_with_vmo(LinearAddress(), descriptor->metadata().size, vmo.copy_ref(), 0, "executable", true, false);
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: 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
if (this != &current->process()) {
// FIXME: Don't force-load the entire executable at once, let the on-demand pager take care of it.
bool success = region->page_in();
ASSERT(success);
}
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: 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
m_regions.append(*region);
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
loader = make<ELFLoader>(region->laddr().as_ptr());
loader->map_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, size_t offset_in_image, bool is_readable, bool is_writable, const String& name) {
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);
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
(void) allocate_region_with_vmo(laddr, size, vmo.copy_ref(), offset_in_image, String(name), is_readable, is_writable);
Kernel: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
return laddr.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
};
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
loader->alloc_section_hook = [&] (LinearAddress laddr, size_t size, size_t alignment, bool is_readable, bool is_writable, const String& name) {
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);
Merge ExecSpace into ELFLoader.
2018-11-04 12:52:53 +00:00
(void) allocate_region(laddr, size, String(name), is_readable, is_writable);
Kernel: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
return laddr.as_ptr();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +00:00
};
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);
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: 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: 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: Allocate kernel signal stacks using the region allocator as well.
2019-05-14 10:06:09 +00:00
current->m_kernel_stack_for_signal_handler_region = 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
current->m_signal_stack_user_region = nullptr;
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];
if (daf.descriptor && daf.flags & FD_CLOEXEC) {
daf.descriptor->close();
daf = { };
}
}
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: 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
Scheduler::prepare_to_modify_tss(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();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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
// ss0 sp!!!!!!!!!
dword old_esp0 = main_thread().m_tss.esp0;
memset(&main_thread().m_tss, 0, sizeof(main_thread().m_tss));
main_thread().m_tss.eflags = 0x0202;
main_thread().m_tss.eip = entry_eip;
main_thread().m_tss.cs = 0x1b;
main_thread().m_tss.ds = 0x23;
main_thread().m_tss.es = 0x23;
main_thread().m_tss.fs = 0x23;
main_thread().m_tss.gs = 0x23;
main_thread().m_tss.ss = 0x23;
main_thread().m_tss.cr3 = page_directory().cr3();
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
main_thread().make_userspace_stack_for_main_thread(move(arguments), move(environment));
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
main_thread().m_tss.ss0 = 0x10;
main_thread().m_tss.esp0 = old_esp0;
main_thread().m_tss.ss2 = m_pid;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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
m_executable = descriptor->inode();
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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 (descriptor->metadata().is_setuid())
m_euid = descriptor->metadata().uid;
if (descriptor->metadata().is_setgid())
m_egid = descriptor->metadata().gid;
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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) exec'd %s @ %p\n", pid(), name().characters(), path.characters(), main_thread().tss().eip);
Implemented sys$execve(). It's really crufty, but it basically works!
2018-11-03 00:49:40 +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
main_thread().set_state(Thread::State::Skip1SchedulerPass);
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: 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
{
// 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
}
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
Process* Process::create_user_process(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
}
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
RetainPtr<Inode> 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))
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
cwd = parent->m_cwd.copy_ref();
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)
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
cwd = VFS::the().root_inode();
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
Coding style fixes in AK.
2019-01-19 21:53:05 +00:00
auto* process = new Process(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: 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) spawned @ %p\n", process->pid(), process->name().characters(), process->main_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
}
The syncd loop can just be a lambda.
2018-12-24 22:10:48 +00:00
Process* Process::create_kernel_process(String&& name, void (*e)())
Unify the Task constructors. There's now Task::create() and Task::createKernelTask().
2018-10-25 09:15:17 +00:00
{
Way tighter locking in process creation. We no longer disable interrupts around the whole affair. Since MM manages per-process data structures, this works quite smoothly now. Only procfs had to be tweaked with an InterruptDisabler.
2018-11-01 13:41:49 +00:00
auto* process = new Process(move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0);
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
process->main_thread().tss().eip = (dword)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: 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("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), process->main_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: 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
process->main_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
}
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
Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RetainPtr<Inode>&& cwd, RetainPtr<Inode>&& 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))
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
, m_pid(next_pid++) // FIXME: RACE: This variable looks racy!
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)
Implement sys$getcwd properly. Also fixed broken strcpy that didn't copy the null terminator.
2018-10-29 23:06:31 +00:00
, m_cwd(move(cwd))
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
, m_executable(move(executable))
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: 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
m_page_directory = PageDirectory::create_for_userspace();
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)
m_main_thread = current->clone(*this);
else
m_main_thread = new Thread(*this);
Kernel: Implement lazy FPU state restore.
2019-01-25 06:52:44 +00:00
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
m_gids.set(m_gid);
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) {
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 (!fork_parent->m_fds[i].descriptor)
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
Use the entry point address from the ELF header instead of looking up _start. I love these kind of dumb gotcha moments. Turns out you can find the entry address right there in the header. :^)
2018-12-29 02:28:55 +00:00
dbgprintf("fork: cloning fd %u... (%p) istty? %u\n", i, fork_parent->m_fds[i].descriptor.ptr(), fork_parent->m_fds[i].descriptor->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
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[i].descriptor = fork_parent->m_fds[i].descriptor->clone();
m_fds[i].flags = fork_parent->m_fds[i].flags;
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: Fix broken destruction order for Process/Thread.
2019-03-24 00:20:35 +00:00
dbgprintf("~Process{%p} name=%s pid=%d, m_fds=%d\n", this, m_name.characters(), pid(), m_fds.size());
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
delete m_main_thread;
m_main_thread = nullptr;
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
Vector<Thread*, 16> my_threads;
for_each_thread([&my_threads] (auto& thread) {
my_threads.append(&thread);
return IterationDecision::Continue;
});
for (auto* thread : my_threads)
delete thread;
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());
Add Regions concept to Task.
2018-10-18 12:53:00 +00:00
kprintf("BEGIN END SIZE NAME\n");
for (auto& region : m_regions) {
kprintf("%x -- %x %x %s\n",
Kernel: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
region->laddr().get(),
region->laddr().offset(region->size() - 1).get(),
region->size(),
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();
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: 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
void Process::create_signal_trampolines_if_needed()
{
if (!m_return_to_ring3_from_signal_trampoline.is_null())
return;
// FIXME: This should be a global trampoline shared by all processes, not one created per process!
// FIXME: Remap as read-only after setup.
auto* region = allocate_region(LinearAddress(), PAGE_SIZE, "Signal trampolines", true, true);
m_return_to_ring3_from_signal_trampoline = region->laddr();
byte* code_ptr = m_return_to_ring3_from_signal_trampoline.as_ptr();
*code_ptr++ = 0x58; // pop eax (Argument to signal handler (ignored here))
*code_ptr++ = 0x5a; // pop edx (Original signal mask to restore)
*code_ptr++ = 0xb8; // mov eax, <dword>
*(dword*)code_ptr = Syscall::SC_restore_signal_mask;
code_ptr += sizeof(dword);
*code_ptr++ = 0xcd; // int 0x82
*code_ptr++ = 0x82;
*code_ptr++ = 0x83; // add esp, (stack alignment padding)
*code_ptr++ = 0xc4;
*code_ptr++ = sizeof(dword) * 3;
*code_ptr++ = 0x61; // popa
*code_ptr++ = 0x9d; // popf
*code_ptr++ = 0xc3; // ret
*code_ptr++ = 0x0f; // ud2
*code_ptr++ = 0x0b;
m_return_to_ring0_from_signal_trampoline = LinearAddress((dword)code_ptr);
*code_ptr++ = 0x58; // pop eax (Argument to signal handler (ignored here))
*code_ptr++ = 0x5a; // pop edx (Original signal mask to restore)
*code_ptr++ = 0xb8; // mov eax, <dword>
*(dword*)code_ptr = Syscall::SC_restore_signal_mask;
code_ptr += sizeof(dword);
*code_ptr++ = 0xcd; // int 0x82
// NOTE: Stack alignment padding doesn't matter when returning to ring0.
// Nothing matters really, as we're returning by replacing the entire TSS.
*code_ptr++ = 0x82;
*code_ptr++ = 0xb8; // mov eax, <dword>
*(dword*)code_ptr = Syscall::SC_sigreturn;
code_ptr += sizeof(dword);
*code_ptr++ = 0xcd; // int 0x82
*code_ptr++ = 0x82;
*code_ptr++ = 0x0f; // ud2
*code_ptr++ = 0x0b;
}
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
int Process::sys$restore_signal_mask(dword mask)
{
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;
}
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
void Process::sys$sigreturn()
{
InterruptDisabler disabler;
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
Scheduler::prepare_to_modify_tss(*current);
Kernel: Shrink Thread by making kernel resume TSS heap-allocated.
2019-04-20 17:23:45 +00:00
current->m_tss = *current->m_tss_to_resume_kernel;
current->m_tss_to_resume_kernel.clear();
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
#ifdef SIGNAL_DEBUG
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
kprintf("sys$sigreturn in %s(%u)\n", name().characters(), pid());
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
auto& tss = current->tss();
kprintf(" -> resuming execution at %w:%x stack %w:%x flags %x cr3 %x\n", tss.cs, tss.eip, tss.ss, tss.esp, tss.eflags, tss.cr3);
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
#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
current->set_state(Thread::State::Skip1SchedulerPass);
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
Scheduler::yield();
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
kprintf("sys$sigreturn failed in %s(%u)\n", name().characters(), pid());
ASSERT_NOT_REACHED();
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
}
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
void Process::crash()
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());
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: Always dump_backtrace() on process crash.
2019-05-16 17:49:48 +00:00
dump_backtrace();
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_signal = SIGSEGV;
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();
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();
Move the scheduler code to its own class. This is very mechanical.
2018-11-07 21:15:02 +00:00
for (auto* process = g_processes->head(); process; process = process->next()) {
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() == 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;
}
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
FileDescriptor* Process::file_descriptor(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())
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].descriptor.ptr();
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
return nullptr;
}
const FileDescriptor* Process::file_descriptor(int fd) const
{
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())
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].descriptor.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: 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;
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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;
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
return descriptor->get_dir_entries((byte*)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
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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;
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
return descriptor->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;
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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;
More coding style changes.
2018-12-02 23:39:25 +00:00
if (!descriptor->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;
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
auto tty_name = descriptor->tty()->tty_name();
if (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;
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
strcpy(buffer, tty_name.characters());
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;
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
auto* master_pty = descriptor->master_pty();
if (!master_pty)
return -ENOTTY;
auto pts_name = master_pty->pts_name();
if (size < pts_name.length() + 1)
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
// FIXME: Return EINVAL if sum of iovecs is greater than INT_MAX
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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
int nwritten = 0;
for (int i = 0; i < iov_count; ++i) {
int rc = do_write(*descriptor, (const byte*)iov[i].iov_base, iov[i].iov_len);
if (rc < 0) {
if (nwritten == 0)
return rc;
return nwritten;
}
nwritten += rc;
}
if (current->has_unmasked_pending_signals()) {
current->block(Thread::State::BlockedSignal);
if (nwritten == 0)
return -EINTR;
}
return nwritten;
}
ssize_t Process::do_write(FileDescriptor& descriptor, const byte* data, int 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
ssize_t nwritten = 0;
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
if (!descriptor.is_blocking()) {
if (!descriptor.can_write())
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
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: 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 (!descriptor.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
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
current->block(Thread::State::BlockedWrite, descriptor);
}
ssize_t rc = descriptor.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;
if (current->has_unmasked_pending_signals()) {
current->block(Thread::State::BlockedSignal);
if (nwritten == 0)
return -EINTR;
}
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;
}
ssize_t Process::sys$write(int fd, const byte* data, ssize_t size)
{
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
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
auto nwritten = do_write(*descriptor, data, size);
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
if (current->has_unmasked_pending_signals()) {
current->block(Thread::State::BlockedSignal);
Before sys$write returns, check for pending unmasked signals. If there is one, put the process into a new BlockedSignal state which makes the next scheduler iteration dispatch the signal.
2018-11-10 01:43:33 +00:00
if (nwritten == 0)
return -EINTR;
}
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 nwritten;
}
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$read(int fd, byte* 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
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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;
More coding style changes.
2018-12-02 23:39:25 +00:00
if (descriptor->is_blocking()) {
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
if (!descriptor->can_read()) {
Kernel: Prepare Socket for becoming a File. Make the Socket functions take a FileDescriptor& rather than a socket role throughout the code. Also change threads to block on a FileDescriptor, rather than either an fd index or a Socket.
2019-05-03 18:15:54 +00:00
current->block(Thread::State::BlockedRead, *descriptor);
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->m_was_interrupted_while_blocked)
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: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
return descriptor->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
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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;
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
int rc = descriptor->close();
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] = { };
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().utime(StringView(pathname), cwd_inode(), 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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().access(StringView(pathname), mode, cwd_inode());
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
}
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
int Process::sys$fcntl(int fd, int cmd, dword arg)
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 09:38:33 +00:00
{
(void) cmd;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
(void) arg;
dbgprintf("sys$fcntl: fd=%d, cmd=%d, arg=%u\n", fd, cmd, arg);
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 09:38:33 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
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
// NOTE: The FD flags are not shared between FileDescriptor objects.
// 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: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
m_fds[new_fd].set(*descriptor);
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:
return descriptor->file_flags();
case F_SETFL:
Add very basic KeyDown events to the GUI event stream. The Terminal program now hosts an interactive shell. :^)
2019-01-15 05:49:52 +00:00
// FIXME: Support changing O_NONBLOCK
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
descriptor->set_file_flags(arg);
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;
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
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
Kernel: Port stat() to KResult/KResultOr<T>.
2019-03-01 23:11:08 +00:00
return descriptor->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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().stat(StringView(path), O_NOFOLLOW_NOERROR, cwd_inode(), *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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().stat(StringView(path), O_NOFOLLOW_NOERROR, cwd_inode(), *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: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
auto result = VFS::the().open(path, O_RDONLY | O_NOFOLLOW_NOERROR, 0, cwd_inode());
if (result.is_error())
return result.error();
auto descriptor = 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
Big, possibly complete sweep of naming changes.
2019-01-31 16:31:23 +00:00
if (!descriptor->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: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
auto contents = descriptor->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.
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
memcpy(buffer, contents.pointer(), 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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
auto directory_or_error = VFS::the().open_directory(StringView(path), cwd_inode());
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();
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: 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: And some more KResult/KResultOr<T> porting work.
2019-03-06 21:30:13 +00:00
auto path_or_error = VFS::the().absolute_path(cwd_inode());
if (path_or_error.is_error())
return path_or_error.error();
auto path = path_or_error.value();
Implement sys$getcwd properly. Also fixed broken strcpy that didn't copy the null terminator.
2018-10-29 23:06:31 +00:00
if (size < path.length() + 1)
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;
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
for (auto& descriptor : m_fds) {
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
if (descriptor)
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: Support open() with O_CREAT. It's now possible to create zero-length files! :^) Also hook up the new functionality in /bin/touch.
2019-01-21 23:58:13 +00:00
int Process::sys$open(const char* path, int options, mode_t mode)
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
{
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
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
dbgprintf("%s(%u) sys$open(\"%s\")\n", name().characters(), pid(), path);
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
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: 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 = VFS::the().open(path, options, mode & ~umask(), cwd_inode());
if (result.is_error())
return result.error();
auto descriptor = result.value();
More coding style changes.
2018-12-02 23:39:25 +00:00
if (options & O_DIRECTORY && !descriptor->is_directory())
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 -ENOTDIR; // FIXME: This should be handled by VFS::open.
Add very basic KeyDown events to the GUI event stream. The Terminal program now hosts an interactive shell. :^)
2019-01-15 05:49:52 +00:00
if (options & O_NONBLOCK)
descriptor->set_blocking(false);
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
dword flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
m_fds[fd].set(move(descriptor), 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;
}
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
int Process::sys$pipe(int pipefd[2])
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: 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: Tidy up FileDescriptor members a bit.
2019-05-18 02:14:22 +00:00
m_fds[reader_fd].set(fifo->open_direction(FIFO::Direction::Reader));
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: Tidy up FileDescriptor members a bit.
2019-05-18 02:14:22 +00:00
m_fds[writer_fd].set(fifo->open_direction(FIFO::Direction::Writer));
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;
(void) pgrp;
ASSERT_NOT_REACHED();
}
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)
{
(void) seconds;
ASSERT_NOT_REACHED();
}
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;
Add sys$uname() and a /bin/uname utility.
2018-10-26 12:56:21 +00:00
strcpy(buf->sysname, "Serenity");
strcpy(buf->release, "1.0-dev");
strcpy(buf->version, "FIXME");
strcpy(buf->machine, "i386");
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;
}
More random compat hacking towards getting bash to build. I'm now at the build stage where it complains about a bajillion missing symbols. This is a good place to be!
2018-11-05 17:16:00 +00:00
int Process::sys$isatty(int fd)
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
More random compat hacking towards getting bash to build. I'm now at the build stage where it complains about a bajillion missing symbols. This is a good place to be!
2018-11-05 17:16:00 +00:00
return -EBADF;
More coding style changes.
2018-12-02 23:39:25 +00:00
if (!descriptor->is_tty())
More random compat hacking towards getting bash to build. I'm now at the build stage where it complains about a bajillion missing symbols. This is a good place to be!
2018-11-05 17:16:00 +00:00
return -ENOTTY;
return 1;
}
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;
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 == 0) {
// FIXME: Send to same-group processes.
ASSERT(pid != 0);
}
if (pid == -1) {
// FIXME: Send to all processes.
ASSERT(pid != -1);
}
Kernel: kill() syscall should support sending a signal to yourself.
2019-02-28 08:44:48 +00:00
if (pid == m_pid) {
Kernel: Introduce threads, and refactor everything in support of it. The scheduler now operates on threads, rather than on processes. Each process has a main thread, and can have any number of additional threads. The process exits when the main thread exits. This patch doesn't actually spawn any additional threads, it merely does all the plumbing needed to make it possible. :^)
2019-03-23 21:03:17 +00:00
current->send_signal(signal, this);
Kernel: kill() syscall should support sending a signal to yourself.
2019-02-28 08:44:48 +00:00
Scheduler::yield();
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: Only allow sending signals to process you own.
2019-02-28 10:45:45 +00:00
// FIXME: Allow sending SIGCONT to everyone in the process group.
// FIXME: Should setuid processes have some special treatment here?
if (!is_superuser() && m_euid != peer->m_uid && m_uid != peer->m_uid)
return -EPERM;
if (peer->is_ring0() && signal == SIGKILL) {
kprintf("%s(%u) attempted to send SIGKILL to ring 0 process %s(%u)\n", name().characters(), m_pid, peer->name().characters(), peer->pid());
return -EPERM;
}
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
peer->send_signal(signal, this);
return 0;
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: Make block() and yield() automatically call Scheduler::yield(). This exposed some places we were accidentally doing a double yield().
2019-03-24 00:52:10 +00:00
current->sleep(usec / 1000);
Kernel: Remove system.h and make the uptime global a qword.
2019-04-13 23:29:14 +00:00
if (current->m_wakeup_time > g_uptime) {
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->m_was_interrupted_while_blocked);
Kernel: Remove system.h and make the uptime global a qword.
2019-04-13 23:29:14 +00:00
dword ticks_left_until_original_wakeup_time = current->m_wakeup_time - g_uptime;
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 ticks_left_until_original_wakeup_time / TICKS_PER_SECOND;
}
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: Make block() and yield() automatically call Scheduler::yield(). This exposed some places we were accidentally doing a double yield().
2019-03-24 00:52:10 +00:00
current->sleep(seconds * TICKS_PER_SECOND);
Kernel: Remove system.h and make the uptime global a qword.
2019-04-13 23:29:14 +00:00
if (current->m_wakeup_time > g_uptime) {
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->m_was_interrupted_while_blocked);
Kernel: Remove system.h and make the uptime global a qword.
2019-04-13 23:29:14 +00:00
dword ticks_left_until_original_wakeup_time = current->m_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;
}
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
void kgettimeofday(timeval& tv)
{
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
tv.tv_sec = RTC::boot_time() + PIT::seconds_since_boot();
tv.tv_usec = PIT::ticks_this_second() * 1000;
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;
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
kgettimeofday(*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
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: Don't disable interrupts during Process destruction.
2019-03-27 13:38:32 +00:00
dbgprintf("reap: %s(%u) {%s}\n", process.name().characters(), process.pid(), to_string(process.state()));
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);
Fix all current build warnings in the kernel.
2018-11-09 09:03:21 +00:00
// FIXME: Respect options
(void) options;
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) {
if (waitee == -1) {
pid_t reaped_pid = 0;
InterruptDisabler disabler;
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
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
}
return true;
});
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: 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_waitee_pid = waitee;
current->block(Thread::State::BlockedWait);
if (current->m_was_interrupted_while_blocked)
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;
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
Process* waitee_process;
{
InterruptDisabler disabler;
Rage hacking to get bash to run. It finally runs. So cool! :^)
2018-11-11 14:36:40 +00:00
// NOTE: If waitee was -1, m_waitee will have been filled in by the scheduler.
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
waitee_process = Process::from_pid(current->m_waitee_pid);
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);
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);
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 current->m_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: 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
enum class KernelMemoryCheckResult {
NotInsideKernelMemory,
AccessGranted,
AccessDenied
};
Kernel: Pass ELF program header locations from multiboot to kernel. Patch contributed by "pd"
2019-05-18 01:06:34 +00:00
// FIXME: Nothing about this is really super...
// This structure is only present at offset 28 in the main multiboot info struct
// if bit 5 of offset 0 (flags) is set. We're just assuming that the flag is set.
//
// Also, there's almost certainly a better way to get that information here than
// a global set by boot.S
//
// Also I'm not 100% sure any of this is correct...
struct mb_elf {
uint32_t num;
uint32_t size;
uint32_t addr;
uint32_t shndx;
};
extern "C" {
void* multiboot_ptr;
}
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
static KernelMemoryCheckResult check_kernel_memory_access(LinearAddress laddr, bool is_write)
Kernel: Unbreak symbolication yet another time.
2019-01-27 09:17:56 +00:00
{
Kernel: Pass ELF program header locations from multiboot to kernel. Patch contributed by "pd"
2019-05-18 01:06:34 +00:00
// FIXME: It would be better to have a proper structure for this...
auto* sections = (const mb_elf*)((const byte*)multiboot_ptr + 28);
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: 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 (laddr.get() < segment.p_vaddr || laddr.get() > (segment.p_vaddr + segment.p_memsz))
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
}
Unbreak ksym loading and make reading /proc/PID/stack not crash.
2019-01-01 01:20:01 +00:00
bool Process::validate_read_from_kernel(LinearAddress laddr) 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: 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
if (laddr.is_null())
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: 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(laddr, false);
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: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
if (is_kmalloc_address(laddr.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: Finally stop exposing Region members to the public.
2019-01-24 17:09:46 +00:00
return validate_read(laddr.as_ptr(), 1);
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);
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
LinearAddress first_address((dword)address);
LinearAddress last_address = first_address.offset(size - 1);
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
ASSERT(size);
if (!size)
return false;
if (first_address.page_base() != last_address.page_base()) {
if (!MM.validate_user_read(*this, last_address))
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
return false;
}
Kernel: Fix incorrect EFAULTs when syscall would write into COW pages.
2019-01-25 00:39:15 +00:00
return MM.validate_user_read(*this, first_address);
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);
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
LinearAddress first_address((dword)address);
LinearAddress last_address = first_address.offset(size - 1);
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;
if (first_address.page_base() != last_address.page_base()) {
if (!MM.validate_user_write(*this, last_address))
Reimplement tcsetattr/tcgetattr as ioctls.
2018-11-16 14:41:48 +00:00
return false;
}
Kernel: Fix incorrect EFAULTs when syscall would write into COW pages.
2019-01-25 00:39:15 +00:00
return MM.validate_user_write(*this, last_address);
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;
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
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;
return false;
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;
if (specified_pgid < 0)
return -EINVAL;
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;
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
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
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: Make ProcessTracer inherit from File.
2019-04-28 13:02:55 +00:00
if (!descriptor->is_file())
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 -ENOTTY;
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
return descriptor->file()->ioctl(*descriptor, 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)
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(old_fd);
if (!descriptor)
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: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
m_fds[new_fd].set(*descriptor);
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)
{
Rename FileHandle to FileDescriptor.
2018-11-07 10:37:54 +00:00
auto* descriptor = file_descriptor(old_fd);
if (!descriptor)
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: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
m_fds[new_fd].set(*descriptor);
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;
action.handler_or_sigaction = LinearAddress((dword)act->sa_sigaction);
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)
return m_gids.size();
Fix all current build warnings in the kernel.
2018-11-09 09:03:21 +00:00
if (count != (int)m_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;
Add templated helpers for read/write validation, and one for strings, too.
2018-11-16 15:23:39 +00:00
if (!validate_write_typed(gids, m_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;
for (auto gid : m_gids)
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;
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
m_gids.clear();
m_gids.set(m_gid);
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 < count; ++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
m_gids.set(gids[i]);
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().mkdir(StringView(pathname, pathname_length), mode & ~umask(), cwd_inode());
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: 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)
{
if (!validate_read_typed(params))
return -EFAULT;
if (params->writefds && !validate_read_typed(params->writefds))
return -EFAULT;
if (params->readfds && !validate_read_typed(params->readfds))
return -EFAULT;
if (params->exceptfds && !validate_read_typed(params->exceptfds))
return -EFAULT;
if (params->timeout && !validate_read_typed(params->timeout))
return -EFAULT;
int nfds = params->nfds;
fd_set* writefds = params->writefds;
fd_set* readfds = params->readfds;
fd_set* exceptfds = params->exceptfds;
auto* timeout = params->timeout;
// FIXME: Implement exceptfds support.
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
(void)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
Kernel: Fix select with a 0 timeout select essentially has 3 modes (which is presumably why we're finding it so hard to get this right in a reliable way :)). 1. NULL timeout -- no timeout on blocking 2. non-NULL timeout that is not zero'd -- timeout on blocking 3. non-NULL but zero timeout -- no blocking at all (immediate poll) For cases 1 and 2, we want to block the thread. We have a timeout set only for case 2, though. Case 3 should not block the thread, and does not have a timeout set.
2019-05-18 16:55:56 +00:00
if (timeout && (timeout->tv_sec || timeout->tv_usec)) {
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
struct timeval now;
kgettimeofday(now);
AK::timeval_add(&now, timeout, &current->m_select_timeout);
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_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
} else {
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_select_has_timeout = false;
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
if (nfds < 0)
return -EINVAL;
// FIXME: Return -EINTR if a signal is caught.
// FIXME: Return -EINVAL if timeout is invalid.
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
auto transfer_fds = [this, nfds] (fd_set* set, 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();
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 (!set)
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
auto bitmap = Bitmap::wrap((byte*)set, FD_SETSIZE);
for (int i = 0; i < nfds; ++i) {
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
if (bitmap.get(i)) {
if (!file_descriptor(i))
return -EBADF;
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
vector.append(i);
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: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
int error = 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
error = transfer_fds(writefds, current->m_select_write_fds);
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
if (error)
return error;
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
error = transfer_fds(readfds, current->m_select_read_fds);
Kernel: select() should fail with EBADF if any set contains an invalid fd.
2019-01-30 18:01:31 +00:00
if (error)
return error;
Kernel: select() was transferring the readfds into the exceptfds vector. Just a mistake I spotted while reading the code. We don't actually detect exceptional descriptor events yet.
2019-05-18 01:09:37 +00:00
error = transfer_fds(exceptfds, current->m_select_exceptional_fds);
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
if (error)
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: 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("%s<%u> selecting on (read:%u, write:%u), timeout=%p\n", name().characters(), pid(), current->m_select_read_fds.size(), current->m_select_write_fds.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: Fix select with a 0 timeout select essentially has 3 modes (which is presumably why we're finding it so hard to get this right in a reliable way :)). 1. NULL timeout -- no timeout on blocking 2. non-NULL timeout that is not zero'd -- timeout on blocking 3. non-NULL but zero timeout -- no blocking at all (immediate poll) For cases 1 and 2, we want to block the thread. We have a timeout set only for case 2, though. Case 3 should not block the thread, and does not have a timeout set.
2019-05-18 16:55:56 +00:00
if (!timeout || current->m_select_has_timeout)
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->block(Thread::State::BlockedSelect);
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 markedfds = 0;
if (readfds) {
memset(readfds, 0, sizeof(fd_set));
auto bitmap = Bitmap::wrap((byte*)readfds, FD_SETSIZE);
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
for (int fd : current->m_select_read_fds) {
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
continue;
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
if (descriptor->can_read()) {
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
bitmap.set(fd, true);
++markedfds;
}
}
}
if (writefds) {
memset(writefds, 0, sizeof(fd_set));
auto bitmap = Bitmap::wrap((byte*)writefds, FD_SETSIZE);
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
for (int fd : current->m_select_write_fds) {
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
auto* descriptor = file_descriptor(fd);
if (!descriptor)
continue;
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
if (descriptor->can_write()) {
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
bitmap.set(fd, true);
++markedfds;
}
}
}
More compat work towards porting vim. It now builds and runs in the small-featureset configuration. :^)
2019-02-26 23:02:01 +00:00
// FIXME: Check for exceptional conditions.
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 markedfds;
}
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: 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_select_write_fds.clear_with_capacity();
current->m_select_read_fds.clear_with_capacity();
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: 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_select_read_fds.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: 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_select_write_fds.append(fds[i].fd);
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
}
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;
struct timeval now;
kgettimeofday(now);
AK::timeval_add(&now, &tvtimeout, &current->m_select_timeout);
current->m_select_has_timeout = true;
} else {
current->m_select_has_timeout = false;
}
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)
dbgprintf("%s<%u> polling on (read:%u, write:%u), timeout=%d\n", name().characters(), pid(), current->m_select_read_fds.size(), current->m_select_write_fds.size(), timeout);
#endif
Kernel: Fix poll() with timeout
2019-05-18 01:59:48 +00:00
if (current->m_select_has_timeout || timeout < 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
current->block(Thread::State::BlockedSelect);
Kernel: Fix poll() with timeout
2019-05-18 01:59:48 +00:00
}
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) {
auto* descriptor = file_descriptor(fds[i].fd);
if (!descriptor) {
fds[i].revents = POLLNVAL;
continue;
}
fds[i].revents = 0;
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
if (fds[i].events & POLLIN && descriptor->can_read())
Kernel: Implement a limited version of POSIX poll().
2019-01-23 07:03:31 +00:00
fds[i].revents |= POLLIN;
Kernel: Have File virtuals take a FileDescriptor& rather than a Process&. This will allow us to implement different behaviors depending on the role of the descriptor a File is being accessed through.
2019-04-29 11:58:40 +00:00
if (fds[i].events & POLLOUT && descriptor->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: Process::cwd_inode() should return a reference. There's always a current working directory inode.
2019-02-21 15:19:07 +00:00
Inode& Process::cwd_inode()
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
{
// FIXME: This is retarded factoring.
if (!m_cwd)
m_cwd = VFS::the().root_inode();
Kernel: Process::cwd_inode() should return a reference. There's always a current working directory inode.
2019-02-21 15:19:07 +00:00
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().link(StringView(old_path), StringView(new_path), cwd_inode());
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().unlink(StringView(pathname), cwd_inode());
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().symlink(StringView(target), StringView(linkpath), cwd_inode());
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().rmdir(StringView(pathname), cwd_inode());
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
}
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
int Process::sys$read_tsc(dword* lsw, dword* msw)
{
if (!validate_write_typed(lsw))
return -EFAULT;
if (!validate_write_typed(msw))
return -EFAULT;
read_tsc(*lsw, *msw);
return 0;
}
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().chmod(StringView(pathname), mode, cwd_inode());
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)
{
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
return descriptor->fchmod(mode);
}
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().chown(StringView(pathname), uid, gid, cwd_inode());
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: 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?
if (parent_process->main_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: 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
{
InterruptDisabler disabler;
for_each_thread([] (Thread& thread) {
if (thread.state() != Thread::State::Dead)
thread.set_state(Thread::State::Dying);
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
if (!Scheduler::is_active())
Scheduler::pick_next_and_switch_now();
}
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) {
amount += region->size();
}
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) {
amount += region->amount_resident();
}
return amount;
}
size_t Process::amount_shared() const
{
// FIXME: This will double count if multiple regions use the same physical page.
// FIXME: It doesn't work at the moment, since it relies on PhysicalPage retain counts,
// and each PhysicalPage is only retained by its VMObject. This needs to be refactored
// so that every Region contributes +1 retain to each of its PhysicalPages.
size_t amount = 0;
for (auto& region : m_regions) {
amount += region->amount_shared();
}
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: Begin implementing UNIX domain sockets.
2019-02-14 13:17:38 +00:00
int Process::sys$socket(int domain, int type, int protocol)
{
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();
auto descriptor = FileDescriptor::create(*result.value());
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)
descriptor->set_blocking(false);
m_fds[fd].set(move(descriptor), 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;
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->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: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->socket();
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
auto result = socket.listen(backlog);
if (result.is_error())
return result;
Kernel: Add SocketRole::Listener and report the role nicely in /proc/PID/fds.
2019-02-17 08:40:52 +00:00
descriptor->set_socket_role(SocketRole::Listener);
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return 0;
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;
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* accepting_socket_descriptor = file_descriptor(accepting_socket_fd);
if (!accepting_socket_descriptor)
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -EBADF;
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
if (!accepting_socket_descriptor->is_socket())
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -ENOTSOCK;
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& socket = *accepting_socket_descriptor->socket();
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
if (!socket.can_accept()) {
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
ASSERT(!accepting_socket_descriptor->is_blocking());
Kernel: More sockets work. Fleshing out accept().
2019-02-14 14:17:30 +00:00
return -EAGAIN;
}
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);
bool success = accepted_socket->get_address(address, address_size);
Kernel: More work on sockets. Getting there..
2019-02-14 14:40:04 +00:00
ASSERT(success);
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_descriptor = FileDescriptor::create(move(accepted_socket), SocketRole::Accepted);
// 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.
accepted_socket_descriptor->set_blocking(accepting_socket_descriptor->is_blocking());
m_fds[accepted_socket_fd].set(move(accepted_socket_descriptor), m_fds[accepting_socket_fd].flags);
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: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
Kernel: connect() should fail with EISCONN for already-connected sockets. Also make sure to reset the socket role if Socket::connect() fails.
2019-03-20 01:38:36 +00:00
if (descriptor->socket_role() == SocketRole::Connected)
return -EISCONN;
Kernel: More work on sockets. Fleshing out connect().
2019-02-14 14:55:19 +00:00
auto& socket = *descriptor->socket();
Kernel: Fix race between accept() and connect(). We had a bug where an accepted socket would appear to be EOF/disconnected on the accepting side until the connecting side had called attach_fd(). Fix this by adding a new SocketRole::Connecting state.
2019-03-20 01:33:51 +00:00
descriptor->set_socket_role(SocketRole::Connecting);
Kernel: Prepare Socket for becoming a File. Make the Socket functions take a FileDescriptor& rather than a socket role throughout the code. Also change threads to block on a FileDescriptor, rather than either an fd index or a Socket.
2019-05-03 18:15:54 +00:00
auto result = socket.connect(*descriptor, address, address_size, descriptor->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
Kernel: connect() should fail with EISCONN for already-connected sockets. Also make sure to reset the socket role if Socket::connect() fails.
2019-03-20 01:38:36 +00:00
if (result.is_error()) {
descriptor->set_socket_role(SocketRole::None);
Kernel: Port more code to KResult and KResultOr<T>.
2019-03-06 21:14:31 +00:00
return result;
Kernel: connect() should fail with EISCONN for already-connected sockets. Also make sure to reset the socket role if Socket::connect() fails.
2019-03-20 01:38:36 +00:00
}
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
descriptor->set_socket_role(SocketRole::Connected);
return 0;
}
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;
int sockfd = params->sockfd;
const void* data = params->data;
size_t data_length = params->data_length;
int flags = params->flags;
auto* addr = (const sockaddr*)params->addr;
auto addr_length = (socklen_t)params->addr_length;
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;
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->socket();
kprintf("sendto %p (%u), flags=%u, addr: %p (%u)\n", data, data_length, flags, addr, addr_length);
Kernel: Prepare Socket for becoming a File. Make the Socket functions take a FileDescriptor& rather than a socket role throughout the code. Also change threads to block on a FileDescriptor, rather than either an fd index or a Socket.
2019-05-03 18:15:54 +00:00
return socket.sendto(*descriptor, 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;
int sockfd = params->sockfd;
void* buffer = params->buffer;
size_t buffer_length = params->buffer_length;
int flags = params->flags;
Kernel: recvfrom() should treat the address arguments as outparams.
2019-03-13 13:47:21 +00:00
auto* addr = (sockaddr*)params->addr;
auto* addr_length = (socklen_t*)params->addr_length;
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) {
return -EINVAL;
}
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
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->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
bool original_blocking = descriptor->is_blocking();
if (flags & MSG_DONTWAIT)
descriptor->set_blocking(false);
auto nrecv = socket.recvfrom(*descriptor, buffer, buffer_length, flags, addr, addr_length);
if (flags & MSG_DONTWAIT)
descriptor->set_blocking(original_blocking);
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;
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->socket();
if (!socket.get_address(addr, addrlen))
return -EINVAL; // FIXME: Should this be another error? I'm not sure.
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;
int sockfd = params->sockfd;
int level = params->level;
int option = params->option;
auto* value = params->value;
auto* value_size = (socklen_t*)params->value_size;
if (!validate_write_typed(value_size))
return -EFAULT;
if (!validate_write(value, *value_size))
return -EFAULT;
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->socket();
return socket.getsockopt(level, option, value, value_size);
}
int Process::sys$setsockopt(const Syscall::SC_setsockopt_params* params)
{
if (!validate_read_typed(params))
return -EFAULT;
int sockfd = params->sockfd;
int level = params->level;
int option = params->option;
auto* value = params->value;
auto value_size = (socklen_t)params->value_size;
if (!validate_read(value, value_size))
return -EFAULT;
auto* descriptor = file_descriptor(sockfd);
if (!descriptor)
return -EBADF;
if (!descriptor->is_socket())
return -ENOTSOCK;
auto& socket = *descriptor->socket();
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
struct SharedBuffer {
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
SharedBuffer(pid_t pid1, pid_t pid2, int 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
: m_pid1(pid1)
, m_pid2(pid2)
, m_vmo(VMObject::create_anonymous(size))
{
ASSERT(pid1 != pid2);
}
void* retain(Process& process)
{
if (m_pid1 == process.pid()) {
++m_pid1_retain_count;
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
if (!m_pid1_region) {
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
m_pid1_region = process.allocate_region_with_vmo(LinearAddress(), size(), m_vmo.copy_ref(), 0, "SharedBuffer", true, m_pid1_writable);
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
m_pid1_region->set_shared(true);
}
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 m_pid1_region->laddr().as_ptr();
} else if (m_pid2 == process.pid()) {
++m_pid2_retain_count;
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
if (!m_pid2_region) {
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
m_pid2_region = process.allocate_region_with_vmo(LinearAddress(), size(), m_vmo.copy_ref(), 0, "SharedBuffer", true, m_pid2_writable);
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
m_pid2_region->set_shared(true);
}
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 m_pid2_region->laddr().as_ptr();
}
return nullptr;
}
void release(Process& process)
{
if (m_pid1 == process.pid()) {
ASSERT(m_pid1_retain_count);
--m_pid1_retain_count;
if (!m_pid1_retain_count) {
if (m_pid1_region)
process.deallocate_region(*m_pid1_region);
m_pid1_region = nullptr;
}
destroy_if_unused();
} else if (m_pid2 == process.pid()) {
ASSERT(m_pid2_retain_count);
--m_pid2_retain_count;
if (!m_pid2_retain_count) {
if (m_pid2_region)
process.deallocate_region(*m_pid2_region);
m_pid2_region = nullptr;
}
destroy_if_unused();
}
}
void disown(pid_t pid)
{
if (m_pid1 == pid) {
m_pid1 = 0;
m_pid1_retain_count = 0;
destroy_if_unused();
} else if (m_pid2 == pid) {
m_pid2 = 0;
m_pid2_retain_count = 0;
destroy_if_unused();
}
}
pid_t pid1() const { return m_pid1; }
pid_t pid2() const { return m_pid2; }
unsigned pid1_retain_count() const { return m_pid1_retain_count; }
unsigned pid2_retain_count() const { return m_pid2_retain_count; }
size_t size() const { return m_vmo->size(); }
void destroy_if_unused();
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
void seal()
{
m_pid1_writable = false;
m_pid2_writable = false;
if (m_pid1_region) {
m_pid1_region->set_writable(false);
MM.remap_region(*m_pid1_region->page_directory(), *m_pid1_region);
}
if (m_pid2_region) {
m_pid2_region->set_writable(false);
MM.remap_region(*m_pid2_region->page_directory(), *m_pid2_region);
}
}
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 m_shared_buffer_id { -1 };
pid_t m_pid1;
pid_t m_pid2;
unsigned m_pid1_retain_count { 1 };
unsigned m_pid2_retain_count { 0 };
Region* m_pid1_region { nullptr };
Region* m_pid2_region { nullptr };
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
bool m_pid1_writable { false };
bool m_pid2_writable { false };
Convert more RetainPtr use to Retained.
2019-02-25 15:04:08 +00:00
Retained<VMObject> m_vmo;
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
};
static int s_next_shared_buffer_id;
Lockable<HashMap<int, OwnPtr<SharedBuffer>>>& shared_buffers()
{
static Lockable<HashMap<int, OwnPtr<SharedBuffer>>>* map;
if (!map)
map = new Lockable<HashMap<int, OwnPtr<SharedBuffer>>>;
return *map;
}
void SharedBuffer::destroy_if_unused()
{
if (!m_pid1_retain_count && !m_pid2_retain_count) {
LOCKER(shared_buffers().lock());
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("Destroying unused SharedBuffer{%p} id: %d (pid1: %d, pid2: %d)\n", this, m_shared_buffer_id, m_pid1, m_pid2);
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/Process: Use auto to avoid incompatible types, causing a signedness warning in the ASSERT
2019-05-17 13:59:57 +00:00
auto count_before = shared_buffers().resource().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
shared_buffers().resource().remove(m_shared_buffer_id);
WindowServer: Support resizing windows. This is pretty limited and not entirely stable, but it does work! :^)
2019-02-20 14:34:55 +00:00
ASSERT(count_before != shared_buffers().resource().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
}
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$create_shared_buffer(pid_t peer_pid, 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 (!peer_pid || peer_pid < 0 || peer_pid == m_pid)
return -EINVAL;
if (!validate_write_typed(buffer))
return -EFAULT;
{
InterruptDisabler disabler;
auto* peer = Process::from_pid(peer_pid);
if (!peer)
return -ESRCH;
}
LOCKER(shared_buffers().lock());
int shared_buffer_id = ++s_next_shared_buffer_id;
auto shared_buffer = make<SharedBuffer>(m_pid, peer_pid, size);
WindowServer: Support resizing windows. This is pretty limited and not entirely stable, but it does work! :^)
2019-02-20 14:34:55 +00:00
shared_buffer->m_shared_buffer_id = shared_buffer_id;
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
ASSERT(shared_buffer->size() >= 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
shared_buffer->m_pid1_region = allocate_region_with_vmo(LinearAddress(), shared_buffer->size(), shared_buffer->m_vmo.copy_ref(), 0, "SharedBuffer", true, true);
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
shared_buffer->m_pid1_region->set_shared(true);
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
*buffer = shared_buffer->m_pid1_region->laddr().as_ptr();
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): Created shared buffer %d (%u bytes, vmo is %u) for sharing with %d\n", name().characters(), pid(),shared_buffer_id, size, shared_buffer->size(), peer_pid);
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));
return shared_buffer_id;
}
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;
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
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_buffer.release(*this);
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;
if (shared_buffer.pid1() != m_pid && shared_buffer.pid2() != m_pid)
return (void*)-EINVAL;
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
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.retain(*this);
}
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;
if (shared_buffer.pid1() != m_pid && shared_buffer.pid2() != m_pid)
return -EINVAL;
#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;
if (shared_buffer.pid1() != m_pid && shared_buffer.pid2() != m_pid)
return -EINVAL;
#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: 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
const char* to_string(Process::Priority priority)
{
switch (priority) {
Kernel: Make the colonel run at "Idle" priority (the lowest possible.) This means it won't hog the CPU for more than a single timeslice. :^)
2019-04-20 13:58:45 +00:00
case Process::IdlePriority: return "Idle";
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
case Process::LowPriority: return "Low";
case Process::NormalPriority: return "Normal";
case Process::HighPriority: return "High";
}
kprintf("to_string(Process::Priority): Invalid priority: %u\n", priority);
ASSERT_NOT_REACHED();
return 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
void Process::terminate_due_to_signal(byte signal)
{
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();
}
void Process::send_signal(byte signal, Process* sender)
{
// FIXME(Thread): Find the appropriate thread to deliver the signal to.
main_thread().send_signal(signal, sender);
}
int Process::thread_count() const
{
int count = 0;
for_each_thread([&count] (auto&) {
++count;
return IterationDecision::Continue;
});
return count;
}
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
int Process::sys$create_thread(int(*entry)(void*), void* argument)
{
if (!validate_read((const void*)entry, sizeof(void*)))
return -EFAULT;
auto* thread = new Thread(*this);
auto& tss = thread->tss();
tss.eip = (dword)entry;
tss.eflags = 0x0202;
tss.cr3 = page_directory().cr3();
thread->make_userspace_stack_for_secondary_thread(argument);
thread->set_state(Thread::State::Runnable);
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
Kernel+LibC: Add exit_thread() syscall.
2019-04-29 13:17:20 +00:00
void Process::sys$exit_thread(int code)
{
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+LibC: Add exit_thread() syscall.
2019-04-29 13:17:20 +00:00
if (&current->process().main_thread() == current) {
sys$exit(code);
return;
}
current->set_state(Thread::State::Dying);
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+LibC: Add exit_thread() syscall.
2019-04-29 13:17:20 +00:00
Scheduler::pick_next_and_switch_now();
ASSERT_NOT_REACHED();
}
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;
for_each_thread([&] (Thread& thread) {
if (thread.tid() == tid) {
beneficiary = &thread;
return IterationDecision::Abort;
}
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: Start using StringView in the VFS class. The less kmalloc() we can do, the better. Calling kmalloc() disables all interrupts while it runs, so it's directly affecting responsiveness.
2019-04-15 12:57:27 +00:00
return VFS::the().rename(StringView(oldpath), StringView(newpath), cwd_inode());
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
int Process::sys$shm_open(const char* name, int flags, mode_t mode)
{
if (!validate_read_str(name))
return -EFAULT;
Kernel: Yet more work on bringing up POSIX SHM.
2019-04-09 00:37:05 +00:00
int fd = alloc_fd();
if (fd < 0)
return fd;
auto shm_or_error = SharedMemory::open(String(name), flags, mode);
if (shm_or_error.is_error())
return shm_or_error.error();
auto descriptor = FileDescriptor::create(shm_or_error.value().ptr());
m_fds[fd].set(move(descriptor), FD_CLOEXEC);
return fd;
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
}
int Process::sys$shm_unlink(const char* name)
{
if (!validate_read_str(name))
return -EFAULT;
Kernel: Yet more work on bringing up POSIX SHM.
2019-04-09 00:37:05 +00:00
return SharedMemory::unlink(String(name));
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)
{
auto* descriptor = file_descriptor(fd);
if (!descriptor)
return -EBADF;
// FIXME: Check that fd is writable, otherwise EINVAL.
if (!descriptor->is_file() && !descriptor->is_shared_memory())
return -EINVAL;
return descriptor->truncate(length);
}
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;
auto descriptor = FileDescriptor::create(peer->ensure_tracer());
m_fds[fd].set(move(descriptor), 0);
return fd;
}
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
void Process::FileDescriptorAndFlags::clear()
{
descriptor = nullptr;
flags = 0;
}
void Process::FileDescriptorAndFlags::set(Retained<FileDescriptor>&& d, dword f)
{
descriptor = move(d);
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;
return VFS::the().mknod(StringView(pathname), mode, dev, cwd_inode());
}
Reference in a new issue Copy permalink