klibc/sem: Add semaphore implementation

errno: Add definition for EOVERFLOW

klibc/mutex: Reduce the amount of code executed in mutex_trylock() while the spinlock is held

klibc/mutex: Move mutex definition to mutex.h and remove unused includes

klibc/mutex: Avoid priority inversion in the mutex implementation

Wake up all tasks waiting on a mutex when it gets unlocked. This way,
the order in which the waiting tasks will acquire the mutex depends
solely on the scheduler (and the tasks priority), not implicitly on
the mutex.

Add "lazy" scheduler implementation

Add simple kernel queue implementation to klibc

Move CPU_ID macro to kernel/include/arch.h

Add generic scheduler interface, to be implemented by all schedulers

Clean up message handling in the stdio daemon by moving it into a separate function

Initialize the heap when starting the net daemon

Remove some unused code from main.c

Implement several of the syscalls of the socket interface

Add some more refined definitions for ipc messages to corax/ipc.h (but don't use them yet)

Correctly check the return value of cxrecv() in vga daemon, print a message during startup

Add strlen() function to userspace libc

Add fork and execfve syscall stubs to userspace libc

Add functions to raise sleeping processes and tasks
 - Implement sched_task_raise()
 - Implement sched_raise()

Fix some minor problems in the process implementation
 - Don't lock tasks in process_task_foreach()
 - Wake up processes when they receive signals

Deliver signals to processes by storing pending signals and accompanying
signal information in the destination process structure, from where the
destination process will retrieve it before returning from an interrupt
or system call. Exception delivery is not affected by this because
exceptions can be delivered directly.

Function implementations added:
 - task_signal_handle()
 - process_put_signal()
 - process_get_signal()
 - process_clear_signal()
 - process_set_sighandler()

Add definitions for SA_* flags to signal.h

Deliver keyboard interrupts to keyboard driver

Clean up kernel/include/arch.h a little and add IRQ() macro

Change return type of _process_hwint_deliver() so that the caller can find out whether or not the interrupt has been successfully delivered

Use parentheses in the definition of sigset_t's val member, otherwise it will be 16 times as large as intended

Implement mechanism to deliver hardware interrupts to userspace processes by
co-opting the sigaction() syscall in combination with a new signal, SIGHWINT.
The signal mask that is passed to sigaction() by means of a struct sigaction
is used to notify the kernel which interrupts the process would like to receive.
Processes that choose to use the same handler for multiple hardware interrupts
should set the SA_SIGINFO flag in the sigaction structure. The interrupt handler
will then be passed an additional siginfo_t structure (and a struct ucontext*)
which can be used to find out the hardware interrupt number by inspecting the
siginfo_t structure's si_trapno member.

Extend task_signal_deliver() function to allow passing of a siginfo_t to the signal handler

Move several definitions from kernel/arch/defs.h to kernel/include/arch.h to make them visible to other parts of the kernel (especially device drivers)

Provide a dummy errno.h

Provide a dummy printf() function in klibc

Implement functions for manipulating sigset_t types in klibc
 - sigemptyset()
 - sigfillset()
 - sigaddset()
 - sigdelset()
 - sigismember()

Add prototypes for functions manipulating sigset_t types

Add assembly stub for sigaction syscall to klibc

Add definition for SYS_SIGACTION

Correct/amend signal.h
 - Add the correct definitions of sigset_t and sigval_t
 - Wrap struct sigaction's sa_handler and sa_sigaction members in a union
 - Add the prototype for sigaction()

Add remark about signal handling in user-mode

Also deliver a signal to a process causing a page fault

sys_debug: Make sure strings are properly NUL-terminated before passing them to dbg_printf()

Add prototype for debug() syscall

Add SIGMAX definition to signal.h

Deliver a POSIX signal to a process that has caused an exception

Implement _task_sig_stub assembly function for tasks executing signal handlers on the way out from the kernel

Add process_get_sighandler() function

Add debug syscall for low-level/last-resort debugging

Add a cast when assigning the return value in sys_mmap(), to avoid compiler warnings

Deliver signals to processes causing exceptions, panic only if the kernel itself causes an exception

Make a thread execute the signal handler itself if it is delivering a signal to the current process (instead of going through the trouble of electing a handling task)

Add prototype for process_signal_deliver() to kernel/include/process.h

Add _exit() syscall to klibc

Add parantheses to SEGM_CS() and SEGM_DS() macros to avoid ambiguousness

Fix return values of sys_inb() and sys_outb()

Statically link against libgcc for now, because of __udivdi3 and __umoddi3

Disable output from dbg_printf() once the init process has been spawned

Include stdio.c in klibc compilation

Fix %% and %c conversion specifications in snprintf() format strings

Add snprintf() implementation to klibc

Make sure _pg_dir_xfer() doesn't copy more data than was requested

Implement sys_cxsendrecv() function

Add simple processes for vga and keyboard handling

Add sys_inb() and sys_outb() syscalls

Add io_inb and io_outb methods for IO-port access on Intel-based platforms

Implement sys_mmap() function

Add assembly stubs, definitions, and prototypes for mmap() and munmap() syscalls

Add pg_dir_mmap() and pg_dir_munmap() functions to implement the low-level half of the mmap() and munmap() syscalls

Add off_t type definition to corax/types.h

Fix order in that objects in the kernel code are linked

Fix function names and prototypes for klibc's heap implementation

Add heap implementation for use in drivers and system services

Make the sbrk() syscall behave as specified in brk(2) with regards to the return value

Smaller fixes to the paging code:
 - Make pg_dir_sbrk() return the address where the heap would start, if there is no heap
 - Don't map any segments but the kernel BSS and TEXT segments into process page directories

Print the affected page directory and page table entries, when a page fault occurs; make sure PAGE_ATTR_WRITABLE is set on the page table, if it contains writable pages

Move _kernel_cr3 back into the .bss segment since we can't get around mapping that into the process page directories anyway

Switch back to the user page directory after having modified the _cpu structure, so it can be removed from the process's page directory

Remove unused reference to _kernel_cr3 from arch/init.S

Move _kernel_cr3 symbol to .text segment

Implement sbrk() POSIX syscall
 - Implement sys_sbrk() syscall handler
 - Add brk() and sbrk() syscall stubs to klibc
 - Add prototypes for brk() and sbrk() to unistd.h

Implement page-directory-level functions to handle heaps
 - Add pg_dir_sbrk() function to handle heap allocation and size adjustments
 - Add pg_dir_get_heap() function to locate the base of the heap
 - Add documentation for pg_dir_map() function

Add ssize_t type to sys/types.h

Include corax/types.h from corax/ipc.h

Implement message handling in stdio process

Add stddef.h header with offsetof() macro

Remove unused local variable from _clone_kernel_region()

Add a fixed-length wait queue to mutexes, to speed up locking and unlocking operations; make use of sched_task_suspend() and sched_task_resume() in mutex implementation

Add sched_task_resume() function

Add definition of EBUSY to corax/errno.h

Make sched.h visible to all parts of the kernel

Suspend the executing task, if the caller of sched_task_suspend() is attempting to suspend itself

Add missing implementation of process_suspend()

Implement sched_task_suspend() function

Lock the process in process_task_foreach()

Protect processes with a spinlock

Add process_task_foreach() function

Protect tasks with a spinlock

Exclude networking code from compilation for now

Remove fds from processes in the kernel

Use a static-size array to keep track of the tasks in a process for now

Add definition of EBADFD to corax/errno.h

Make use of fork() and execfve() to spawn STDIO and NET daemons

Move cxsend(), cxrecv(), cxsendrecv() syscalls from core into klibc

Move fork() and execfve() syscalls from core to klibc