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

Add spinlock implementation (should have been in commit aa0e4586dd3efe434b34ae7956a4c27220cb798d)

Add execfve() syscall

Add mutex implementation to klibc

Add spinlock implementation to klibc

Use standard C functions from klibc within the kernel

Add memset() function to klibc

Add standard C library for use inside the kernel

Add CONFIG_DEBUG_HEAP definition to config.h

Add unistd.h header

Add SYS_SLEEP and SYS_EXECFVE definitions to corax/syscall.h

Skip kernel regions in _fork_region() and _vfork_region()

Add kernel regions correctly in pg_dir_map_region(), use pg_dir_map_region() in _clone_kernel_region() function

Directly map read-only regions instead of copying them, when forking a process

Make use of pg_dir_foreach_region() function in process_create() function to clone or map memory regions of the parent process, where necessary

Add pg_dir_clone_region() method for copying a region from one page directory into another one

Make several amendments to the paging code to facilitate process memory management:
 - Move definition of struct region to kernel-wide arch.h header
 - Make page directories refer to their regions through a pointer array rather than a linked list
 - Add pg_dir_foreach_region() function for iterating over the mappings in a page directory
 - Add pg_dir_map_region() function for mapping a region from one page directory into another
 - Add a reference counter to each region
 - Add flags to regions so they can be marked as private, shared, or kernel-related

Add some paging and permission-related configuration options

Add definition of ERANGE

Add task_move_stack() function, which moves the current stack and updates ESP and EBP

Add some methods for process_t types:
 - process_set_pagedir() / process_get_pagedir() - Convenience functions to access the process's pagedir
 - process_setuid() - Set the process's user id
 - process_setgid() - Set the process's group id

Add definitions for EPERM and EACCES

Start implementation of facilities to support userspace processes
 - Add crxstd.h header with prototypes for Corax-specific syscalls
 - Add dummy NET process
 - Add dummy STDIO process
 - Start NET and STDIO processes from process daemon

Make kernel spawn the idle and init processes in main.c, perform any other testing in the init process, once it's working

Implement process ownership and inheritance