ladybird/Libraries/LibC/serenity.h

#pragma once

#include <stdio.h>
#include <unistd.h>

__BEGIN_DECLS

int module_load(const char* path, size_t path_length);
int module_unload(const char* name, size_t name_length);

int profiling_enable(pid_t);
int profiling_disable(pid_t);

#define THREAD_PRIORITY_MIN 1
#define THREAD_PRIORITY_LOW 10
#define THREAD_PRIORITY_NORMAL 30
#define THREAD_PRIORITY_HIGH 50
#define THREAD_PRIORITY_MAX 99

int set_thread_boost(int tid, int amount);
int set_process_boost(pid_t, int amount);

#define FUTEX_WAIT 1
#define FUTEX_WAKE 2

int futex(int32_t* userspace_address, int futex_op, int32_t value, const struct timespec* timeout);

#define PURGE_ALL_VOLATILE 0x1
#define PURGE_ALL_CLEAN_INODE 0x2

int purge(int mode);

__END_DECLS
LibC: Move Stopwatch thingy into a <serenity.h> header. This thing is extremely useful for performance testing so let's put it here. 2019-01-28 23:01:47 +01:00			`#pragma once`

			`#include <stdio.h>`
			`#include <unistd.h>`

Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module. 2019-11-28 20:59:11 +01:00			`__BEGIN_DECLS`

			`int module_load(const char* path, size_t path_length);`
			`int module_unload(const char* name, size_t name_length);`

Kernel: Implement a simple process time profiler The kernel now supports basic profiling of all the threads in a process by calling profiling_enable(pid_t). You finish the profiling by calling profiling_disable(pid_t). This all works by recording thread stacks when the timer interrupt fires and the current thread is in a process being profiled. Note that symbolication is deferred until profiling_disable() to avoid adding more noise than necessary to the profile. A simple "/bin/profile" command is included here that can be used to start/stop profiling like so: $ profile 10 on ... wait ... $ profile 10 off After a profile has been recorded, it can be fetched in /proc/profile There are various limits (or "bugs") on this mechanism at the moment: - Only one process can be profiled at a time. - We allocate 8MB for the samples, if you use more space, things will not work, and probably break a bit. - Things will probably fall apart if the profiled process dies during profiling, or while extracing /proc/profile 2019-12-11 20:36:56 +01:00			`int profiling_enable(pid_t);`
			`int profiling_disable(pid_t);`

Kernel: Refactor scheduler to use dynamic thread priorities Threads now have numeric priorities with a base priority in the 1-99 range. Whenever a runnable thread is not scheduled, its effective priority is incremented by 1. This is tracked in Thread::m_extra_priority. The effective priority of a thread is m_priority + m_extra_priority. When a runnable thread is scheduled, its m_extra_priority is reset to zero and the effective priority returns to base. This means that lower-priority threads will always eventually get scheduled to run, once its effective priority becomes high enough to exceed the base priority of threads "above" it. The previous values for ThreadPriority (Low, Normal and High) are now replaced as follows: Low -> 10 Normal -> 30 High -> 50 In other words, it will take 20 ticks for a "Low" priority thread to get to "Normal" effective priority, and another 20 to reach "High". This is not perfect, and I've used some quite naive data structures, but I think the mechanism will allow us to build various new and interesting optimizations, and we can figure out better data structures later on. :^) 2019-12-30 18:46:17 +01:00			`#define THREAD_PRIORITY_MIN 1`
			`#define THREAD_PRIORITY_LOW 10`
			`#define THREAD_PRIORITY_NORMAL 30`
			`#define THREAD_PRIORITY_HIGH 50`
			`#define THREAD_PRIORITY_MAX 99`

Kernel: Add a basic thread boosting mechanism This patch introduces a syscall: int set_thread_boost(int tid, int amount) You can use this to add a permanent boost value to the effective thread priority of any thread with your UID (or any thread in the system if you are the superuser.) This is quite crude, but opens up some interesting opportunities. :^) 2019-12-30 19:23:13 +01:00			`int set_thread_boost(int tid, int amount);`
Kernel: Also add a process boosting mechanism Let's also have set_process_boost() for giving all threads in a process the same boost. 2019-12-30 20:10:00 +01:00			`int set_process_boost(pid_t, int amount);`
Kernel: Add a basic thread boosting mechanism This patch introduces a syscall: int set_thread_boost(int tid, int amount) You can use this to add a permanent boost value to the effective thread priority of any thread with your UID (or any thread in the system if you are the superuser.) This is quite crude, but opens up some interesting opportunities. :^) 2019-12-30 19:23:13 +01:00
Kernel+LibPthread+LibC: Add a naive futex and use it for pthread_cond_t This patch implements a simple version of the futex (fast userspace mutex) API in the kernel and uses it to make the pthread_cond_t API's block instead of busily sched_yield(). An arbitrary userspace address is passed to the kernel as a "token" that identifies the futex and you can then FUTEX_WAIT and FUTEX_WAKE that specific userspace address. FUTEX_WAIT corresponds to pthread_cond_wait() and FUTEX_WAKE is used for pthread_cond_signal() and pthread_cond_broadcast(). I'm pretty sure I'm missing something in this implementation, but it's hopefully okay for a start. :^) 2019-12-22 21:29:47 +01:00			`#define FUTEX_WAIT 1`
			`#define FUTEX_WAKE 2`

			`int futex(int32_t* userspace_address, int futex_op, int32_t value, const struct timespec* timeout);`

LibC+Userland: Add a proper syscall wrapper for purge() 2020-01-02 13:37:02 +01:00			`#define PURGE_ALL_VOLATILE 0x1`
			`#define PURGE_ALL_CLEAN_INODE 0x2`

			`int purge(int mode);`

Kernel: Implement very simple kernel module loading It's now possible to load a .o file into the kernel via a syscall. The kernel will perform all the necessary ELF relocations, and then call the "module_init" symbol in the loaded module. 2019-11-28 20:59:11 +01:00			`__END_DECLS`