LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-20 09:49:15 +03:00
Code Issues Packages Projects Releases Wiki Activity
711e2b2651
ladybird/Kernel/Syscall.h

167 lines
4.5 KiB
C
Raw Normal View History

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 12:01:38 +03:00
#pragma once
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
#include <AK/Types.h>
More compat work. Rename libraries from LibFoo.a => libfoo.a This makes it more straightforward to build a cross-compiler toolchain. Also move math stuff from LibC to LibM.
2019-02-26 15:30:57 +03:00
#include <LibC/fd_set.h>
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
Change syscall naming scheme.
2018-11-06 15:23:22 +03:00
#define ENUMERATE_SYSCALLS \
__ENUMERATE_SYSCALL(sleep) \
__ENUMERATE_SYSCALL(yield) \
__ENUMERATE_SYSCALL(putch) \
__ENUMERATE_SYSCALL(open) \
__ENUMERATE_SYSCALL(close) \
__ENUMERATE_SYSCALL(read) \
__ENUMERATE_SYSCALL(lseek) \
__ENUMERATE_SYSCALL(kill) \
__ENUMERATE_SYSCALL(getuid) \
__ENUMERATE_SYSCALL(exit) \
__ENUMERATE_SYSCALL(getgid) \
__ENUMERATE_SYSCALL(getpid) \
__ENUMERATE_SYSCALL(waitpid) \
__ENUMERATE_SYSCALL(mmap) \
__ENUMERATE_SYSCALL(munmap) \
__ENUMERATE_SYSCALL(get_dir_entries) \
__ENUMERATE_SYSCALL(lstat) \
__ENUMERATE_SYSCALL(getcwd) \
__ENUMERATE_SYSCALL(gettimeofday) \
__ENUMERATE_SYSCALL(gethostname) \
__ENUMERATE_SYSCALL(chdir) \
__ENUMERATE_SYSCALL(uname) \
__ENUMERATE_SYSCALL(set_mmap_name) \
__ENUMERATE_SYSCALL(readlink) \
__ENUMERATE_SYSCALL(write) \
__ENUMERATE_SYSCALL(ttyname_r) \
__ENUMERATE_SYSCALL(stat) \
__ENUMERATE_SYSCALL(getsid) \
__ENUMERATE_SYSCALL(setsid) \
__ENUMERATE_SYSCALL(getpgid) \
__ENUMERATE_SYSCALL(setpgid) \
__ENUMERATE_SYSCALL(getpgrp) \
__ENUMERATE_SYSCALL(fork) \
__ENUMERATE_SYSCALL(execve) \
__ENUMERATE_SYSCALL(geteuid) \
__ENUMERATE_SYSCALL(getegid) \
__ENUMERATE_SYSCALL(isatty) \
__ENUMERATE_SYSCALL(getdtablesize) \
__ENUMERATE_SYSCALL(dup) \
__ENUMERATE_SYSCALL(dup2) \
__ENUMERATE_SYSCALL(sigaction) \
Add getppid().
2018-11-06 15:33:06 +03:00
__ENUMERATE_SYSCALL(getppid) \
Add umask().
2018-11-06 15:40:23 +03:00
__ENUMERATE_SYSCALL(umask) \
Add some basic setgroups(), getgroups() and initgroups(). Also teach /bin/id to print the user's supplemental groups.
2018-11-07 03:38:51 +03:00
__ENUMERATE_SYSCALL(getgroups) \
__ENUMERATE_SYSCALL(setgroups) \
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 23:19:47 +03:00
__ENUMERATE_SYSCALL(sigreturn) \
Some improvements to signals. - Add sigprocmask() and sigpending(). - Forked children inherit signal dispositions and masks. - Exec clears signal dispositions and masks.
2018-11-11 01:29:07 +03:00
__ENUMERATE_SYSCALL(sigprocmask) \
__ENUMERATE_SYSCALL(sigpending) \
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-11 02:20:53 +03:00
__ENUMERATE_SYSCALL(pipe) \
__ENUMERATE_SYSCALL(killpg) \
__ENUMERATE_SYSCALL(setuid) \
__ENUMERATE_SYSCALL(setgid) \
__ENUMERATE_SYSCALL(alarm) \
__ENUMERATE_SYSCALL(fstat) \
__ENUMERATE_SYSCALL(access) \
Stub out a bunch more functions to get closer to that sweet bash build.
2018-11-11 12:38:33 +03:00
__ENUMERATE_SYSCALL(fcntl) \
Add ioctl() and reimplement tcsetpgrp/tcsetpgrp as ioctls.
2018-11-16 15:11:21 +03:00
__ENUMERATE_SYSCALL(ioctl) \
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 16:57:41 +03:00
__ENUMERATE_SYSCALL(mkdir) \
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 03:12:26 +03:00
__ENUMERATE_SYSCALL(times) \
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 23:14:55 +03:00
__ENUMERATE_SYSCALL(utime) \
Add sync() syscall and a /bin/sync. It walks all the live Inode objects and flushes pending metadata changes wherever needed. This could be optimized by keeping a separate list of dirty Inodes, but let's not get ahead of ourselves.
2018-12-20 02:39:29 +03:00
__ENUMERATE_SYSCALL(sync) \
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 08:30:19 +03:00
__ENUMERATE_SYSCALL(ptsname_r) \
Let userland retain the window backing store while drawing into it. To start painting, call: gui$get_window_backing_store() Then finish up with: gui$release_window_backing_store() Process will retain the underlying GraphicsBitmap behind the scenes. This fixes racing between the WindowServer and GUI clients. This patch also adds a WSWindowLocker that is exactly what it sounds like.
2019-01-25 01:40:12 +03:00
__ENUMERATE_SYSCALL(select) \
__ENUMERATE_SYSCALL(unlink) \
__ENUMERATE_SYSCALL(poll) \
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 04:09:29 +03:00
__ENUMERATE_SYSCALL(read_tsc) \
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 06:16:01 +03:00
__ENUMERATE_SYSCALL(rmdir) \
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 06:55:08 +03:00
__ENUMERATE_SYSCALL(chmod) \
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 18:11:28 +03:00
__ENUMERATE_SYSCALL(usleep) \
Kernel: Begin implementing UNIX domain sockets.
2019-02-14 16:17:38 +03:00
__ENUMERATE_SYSCALL(socket) \
__ENUMERATE_SYSCALL(bind) \
__ENUMERATE_SYSCALL(accept) \
__ENUMERATE_SYSCALL(listen) \
__ENUMERATE_SYSCALL(connect) \
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 14:13:43 +03:00
__ENUMERATE_SYSCALL(create_shared_buffer) \
__ENUMERATE_SYSCALL(get_shared_buffer) \
__ENUMERATE_SYSCALL(release_shared_buffer) \
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 15:26:40 +03:00
__ENUMERATE_SYSCALL(link) \
Share GraphicsBitmaps between the windowing server and the client process. This is pretty cool. :^) GraphicsBitmaps are now mapped into both the server and the client address space (usually at different addresses but that doesn't matter.) Added a GUI syscall for getting a window's backing store, and another one for invalidating a window so that the server redraws it.
2019-01-14 17:25:34 +03:00
Change syscall naming scheme.
2018-11-06 15:23:22 +03: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 12:01:38 +03:00
namespace Syscall {
enum Function {
Change syscall naming scheme.
2018-11-06 15:23:22 +03:00
#undef __ENUMERATE_SYSCALL
#define __ENUMERATE_SYSCALL(x) SC_ ##x ,
ENUMERATE_SYSCALLS
#undef __ENUMERATE_SYSCALL
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 12:01:38 +03:00
};
Big, possibly complete sweep of naming changes.
2019-01-31 19:31:23 +03:00
inline constexpr const char* to_string(Function function)
Change syscall naming scheme.
2018-11-06 15:23:22 +03:00
{
switch (function) {
#undef __ENUMERATE_SYSCALL
#define __ENUMERATE_SYSCALL(x) case SC_ ##x: return #x;
ENUMERATE_SYSCALLS
#undef __ENUMERATE_SYSCALL
}
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 23:19:47 +03:00
return "Unknown";
Change syscall naming scheme.
2018-11-06 15:23:22 +03:00
}
Kernel: Fix Syscall.h build when out of context.
2019-01-25 07:19:29 +03:00
#ifdef SERENITY
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 13:37:01 +03:00
struct SC_mmap_params {
uint32_t addr;
uint32_t size;
int32_t prot;
int32_t flags;
int32_t fd;
Fix all current build warnings in LibC.
2018-11-09 12:09:46 +03:00
int32_t offset; // FIXME: 64-bit off_t?
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 13:37:01 +03: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-16 01:12:20 +03:00
struct SC_select_params {
int nfds;
fd_set* readfds;
fd_set* writefds;
fd_set* exceptfds;
struct timeval* timeout;
};
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 12:01:38 +03:00
void initialize();
Add a "syncd" kernel process that periodically calls sync().
2018-12-20 04:41:55 +03:00
int sync();
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 14:05:00 +03:00
Add ioctl() and reimplement tcsetpgrp/tcsetpgrp as ioctls.
2018-11-16 15:11:21 +03:00
inline dword invoke(Function function)
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 14:05:00 +03:00
{
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
dword result;
More compat work. Move syscall to int 0x82 since using int 0x80 was kinda prone to fork bombs when building things on Linux. :^)
2019-02-26 14:57:02 +03:00
asm volatile("int $0x82":"=a"(result):"a"(function):"memory");
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 14:05:00 +03:00
return result;
}
Make syscall invocations look pleasant. Old: Syscall::invoke(Syscall::SC_foo, (dword)arg1, (dword)arg2) New: syscall(SC_foo, arg1, arg2)
2018-12-21 05:02:06 +03:00
template<typename T1>
inline dword invoke(Function function, T1 arg1)
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 14:05:00 +03:00
{
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
dword result;
More compat work. Move syscall to int 0x82 since using int 0x80 was kinda prone to fork bombs when building things on Linux. :^)
2019-02-26 14:57:02 +03:00
asm volatile("int $0x82":"=a"(result):"a"(function),"d"((dword)arg1):"memory");
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 14:05:00 +03:00
return result;
}
Make syscall invocations look pleasant. Old: Syscall::invoke(Syscall::SC_foo, (dword)arg1, (dword)arg2) New: syscall(SC_foo, arg1, arg2)
2018-12-21 05:02:06 +03:00
template<typename T1, typename T2>
inline dword invoke(Function function, T1 arg1, T2 arg2)
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 14:05:00 +03:00
{
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
dword result;
More compat work. Move syscall to int 0x82 since using int 0x80 was kinda prone to fork bombs when building things on Linux. :^)
2019-02-26 14:57:02 +03:00
asm volatile("int $0x82":"=a"(result):"a"(function),"d"((dword)arg1),"c"((dword)arg2):"memory");
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 14:05:00 +03:00
return result;
}
Make syscall invocations look pleasant. Old: Syscall::invoke(Syscall::SC_foo, (dword)arg1, (dword)arg2) New: syscall(SC_foo, arg1, arg2)
2018-12-21 05:02:06 +03:00
template<typename T1, typename T2, typename T3>
inline dword invoke(Function function, T1 arg1, T2 arg2, T3 arg3)
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 14:05:00 +03:00
{
Add getgid() and getpid() syscalls. Prep for LibC.
2018-10-22 14:55:11 +03:00
dword result;
More compat work. Move syscall to int 0x82 since using int 0x80 was kinda prone to fork bombs when building things on Linux. :^)
2019-02-26 14:57:02 +03:00
asm volatile("int $0x82":"=a"(result):"a"(function),"d"((dword)arg1),"c"((dword)arg2),"b"((dword)arg3):"memory");
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 14:05:00 +03:00
return result;
}
Kernel: Fix Syscall.h build when out of context.
2019-01-25 07:19:29 +03:00
#endif
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 12:01:38 +03:00
}
Make syscall invocations look pleasant. Old: Syscall::invoke(Syscall::SC_foo, (dword)arg1, (dword)arg2) New: syscall(SC_foo, arg1, arg2)
2018-12-21 05:02:06 +03:00
#undef __ENUMERATE_SYSCALL
#define __ENUMERATE_SYSCALL(x) using Syscall::SC_ ##x;
ENUMERATE_SYSCALLS
#undef __ENUMERATE_SYSCALL
#define syscall Syscall::invoke
Reference in New Issue Copy Permalink