corax/sys: Add initfs infrastructure

kernel/core: Wake up sleeping processes upon signal reception

sched/lazy: Fix bug in _lazy_tick() causing waiting processes to be scheduled

kernel/kbd: Add debug output to see what's going on in kbd_main()

kernel/core: Make mailbox_get() return -EINTR if the call to sem_wait() failed

klibc/sem: Make sem_wait() return -EINTR if interrupted due to a signal

kernel/kbd: Make the interrupt handler print something

kernel/core: Make init process wait() indefinitely, for now

sched/lazy: Make sure _lazy_tick() doesn't break if ctask is NULL, which happens the first time it is called

kernel/arch: Fix task_lock() and task_unlock() functions

core/process: Use new scheduler calls, fix compiler warnings

kernel/core: Include <sys/wait.h> from main.c

core/posixcall: Use sched_sleep() to suspend running task, instead of process_wait(), fix compiler warning

kernel/include: Remove prototypes for old scheduler functions

include/sys: Add sys/wait.h header

kernel/vga: Remove unused variable

kernel/core: Use IPC mailboxes in process and cxipc implementation

kernel/core: Finish IPC mailbox implementation

kernel/core: Add -nostdinc -fno-builtin -fno-builtin-memcpy to Makefile

Add header with documentation for IPC mailboxes, along with a half-baked implementation

Add sizeof_a() convenience macro for determining the number of elements in a static array

kernel/klibc: Add FCFS-semaphore implementation
 - Add ffs type and ffs_* functions
 - Fix grammar in documentation of sem_* functions
 - Make sure lines in sem.h don't exceed 80 columns

klibc/sem: Add sem_peek() method and documentation for all semaphore functions

kernel/core: Exclude sched.c from compilation

sched/common: Define __SCHED_COMMON in common.c so that scheduler-global variables will be declared

kernel/core: Initialize the scheduler at boot time

arch/interrupt: Remove declaration of sched_wait() and include <sched.h> instead

Merge branch 'sched-next' of ssh://corax.cc:2975/home/mk/devel/corax into sched-next

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.

Change pid_t to be a signed integer, in accordance with IEEE Std 1003.1-2004

Make sure klibc is the last element in OBJECTS

Fix compiler errors and warnings in lazy scheduler

Add EINTR to <corax/errno.h>

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