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

Add dummy process_suspend() function

Implement some basic handling of POSIX signals

Add prototype of _pg_dir_vpxlate() to arch.h

Add signal.h header

Add prototype for _pg_dir_vpxlate() to arch/paging.h

Add uid_t and gid_t types, and definitions for UID_ROOT and GID_ROOT

Implement process_detach() method, to create a new session for a process, i.e. detach it from its parent

Modify process_create() function to finalize sys_fork() implementation:
 - Copy the contents of the user-mode stack
 - Call task_prepare_fork to copy/modify the new task's kernel-mode stack
 - Set the state of the new task to TASK_STATE_FORKED
 - Set t_pgdir and other values that would normally be set by task_prepare

Allow forked processes to be enqueued using sched_enqueue()

Add task_prepare_fork method and modify task_switch to facilitate the implementation of sys_fork()

Change the signature of sys_posixcall() so it can modify the caller's stackframe in the case of sys_fork()

Move definition of struct stack_frame to arch.h

Add implementation of process_fork(), modify process_create() so that it can be used to fork a running process

Call process_fork() from sys_fork() and sys_vfork()

Call process_exit() from sys_exit()

Add process_exit() function

Minor improvements to the scheduler:
 - Make _unq() return an error if it didn't succeed
 - Add sched_dequeue() function
 - Modify sched_tick() not to put tasks with TASK_STATE_EXIT back onto the ready queue
 - Add a header with prototypes for the functions implemented in sched.c

Add TASK_STATE_EXIT state to identify tasks that are exitting

Add an argument to process_create() so the caller may request the process to be created with a specific pid

Add syscall stubs for some POSIX process management syscalls (fork, vfork, exit, ...)

Temporarily add assembly stubs for syscalls, to avoid having to link against the C library

Add some IPC testing code to main.c

Make debug output in IPC code depend on CONFIG_DEBUG_IPC

Signal the receiving process in process_inbox_put()

Print the address and pid of the executing context when an exception occurs

Implement various IPC and scheduling improvements:
 - Implement signalling/waiting facilities for processes and tasks
 - Implement primitive message passing between processes
 - Implement helper functions for accesing properties of a process
 - Also keep the pid within the task structure, for faster access
 - Add a wait-queue to the scheduler, to keep track of waiting processes

Add CONFIG_IPC_MSGSIZE configuration option

Add definitions for ENOTSUP, EOPNOTSUPP, and ENOENT

Add typedef for pid_t

Implement process_memcpy_ptop() function for copying data directly between processes

Add mbuf type and functions to allocate and free them

Add sobind() function stub and call it from sys_bind()

Also compile libc from the top-level Makefile

Add dummy soshutdown() function and call it from sys_shutdown()

Start implementation of a statically linked standard C library:
 - Add implementation of network-related syscalls

Implement sys_getsockopt() and sys_setsockopt() functions