ManRiX
THE DESIGN OF ROBUST AND EFFICIENT MICROKERNEL

ManRiX Microkernel Services :
Thread And Process managenemt
Symmetric Multiprocessor(SMP):
Interprocess Communication:
Virtual Memory management:
Timers management:
Signal management:
Exception & IRQS:
Kernel Preemption:
Schedular

ManRiX's Microkernel Architecture

ManRiX is a microkernel based operating system. Microkernel contents the few essential servicea of kernel. Those components which are not required inside kernel are implemented as user servers . The ManRix microkernel performs the following tasks:

•  Thread Management.
•  Inter Process Communication (IPC) using Message Passing.
•  Memory management.
•  Signal & Timer management.
•  Exception and IRQ handling:

OS Initialization:
The OS initialization Process is Architecture Dependent. We will try to explain how ManRiX is initialized in I386. After the Microkernel Image and System Servers’ Image are loaded in memory by Boot Loader, the _start function on kernel_entry.S begins to execute and later calls the C function ManRiX_main(). The kernel only runs on the Context of a process during System Calls and on the Interrupt Context during Interrupt. Overall step how ManRiX boot can be found in this link.

Processes and Threads are the two basic concepts of program. In ManRiX microkernel, threads are the fundamental units of execution. Processes are inactive entity. Process just encapsulates the threads and address space. Threads are scheduled independently no matter to which process they belong. Each thread has two set of Stack one for running in Kernel Mode called Kernel Stack and for User stack for user mode.
Each process contains a unique Process ID called pid and each thread contains unique thread ID called tid. The pid and tid are not unique to each other. The Users can Create Process by using POSIX fork and exec functions and Threads by using pthreads functions.

Inter Process Communication is Heart of any Microkernel Based System. In ManRiX Microkernel, Message passing is used as the IPC. We are using Synchronous message passing. The message is sent directly sent to another thread using tid. There are basically three types of Messages in ManRiX. We have basically three types of Messages. They are SHORT, LONG and MAP.

The SHORT messages are passed Only in CPU Registers. This is used in IPC where messages to send and receive are very short and fit in general purpose resisters. This type of message passing is extremely fast but can accommodate short messages (32 bytes).
In LONG messages, the Messages are copied from one Address Space to another. This is not possible directly so we are first copying to Kernel and then to another address space. Usually, the Messages shorter than 256 Bytes are Long Transferred. It is quite slower than SHORT messages.
And In the MAP messaging, the messages are NOT actually transferred but the page tables are mapped. This is not efficient For short messages.

Signals provide a mechanism for notifying processes of system events. They also function as a primitive mechanism for communication and synchronization between user processes. ManRiX supports POSIX signals. It has also a limited support of POSIX real-time signals. ManRiX supports 32 different signals. 26 of them are standard POSIX signals and 5 are Real-time Signals. In ManRiX signal handlers are per process objects. All threads in a process share same signals handlers but have their own signal mask.

The supported non-real signals are (from SUSV3)

Where, First row denotes Symbolic Name for signal. Second row shows the default action to take on signal receipt.

I = ignore
T = terminate
A = Abort
S = Stop process
C = Continue process
The real time signals are from SIGRTMIN to SIGRTMAX. The signal handlers are the per process entity whereas signal mask are per thread entity. If a thread catches a thread, it affects all the threads belonging to that process. If a signal is targeted to a process, the thread which has that signal unblocked will receive the signal. The signal is checked while returning from kernel. So, the signal may not be delivered as soon as it arrives.
In microkernel, all signals are queued. The ignored signals are not queued. Our OS has 5 system calls related to POSIX signals.

1.Signal_action:This system call defines action to take on receipt of a signal. The parameters are

•  signal number
•  Pointer to act structure
•  Pointer to oact structure

This system call is used to service following POSIX calls.
int sigaction(int sig , const struct sigaction *restrict act ,
       struct sigaction *restrict oact );
void (*signal(int sig , void (* func )(int)))(int); (ISO C standard)

This system call is used to service following POSIX calls.
int pthread_sigmask(int how , const sigset_t *restrict set ,
       sigset_t *restrict oset );
int sigprocmask(int how , const sigset_t *restrict set ,
       sigset_t *restrict oset );
kill

This system call sends a signal to a particular thread or process. The parameters are:
•  pid or tid
•  signal number
•  flags

SIG_REAL /* for sigqueue */
TO_THREAD /* signal sent to a thread eg. pthread_kill()*/
TO_PROCESS /* signal sent to a process eg. kill() */
•  pointer to sigval (used by sigqueue)

This system call is used to service following POSIX calls.
int kill(pid_t pid , int sig );
int raise(int sig );
int sigqueue(pid_t pid , int signo , const union sigval value );
int pthread_kill(pthread_t thread , int sig );

signal_suspend :

This system call suspends the thread until any signal is delivered. The parameters are:
signal set (used by sigsuspend)

This system call is used to service following POSIX calls.
int sigsuspend(const sigset_t * sigmask );
int pause(void);
1. sigreturn
This system call is used to return from user's signal handler.

ManRiX does not handle devices in kernel space. They can be implemented in user space using a set of interfaces. The ManRiX microkernel sends appropriate signals to the corresponding threads on CPU exceptions.
The ManRiX microkernel doesn’t handle interrupt request in kernel space. It only acts as an IRQ redirector. For IRQ handling the User thread can register a handler for an IRQ. On the arrival of IRQ event, the Kernel finds the handler(s) for that IRQ and runs the handler. The IRQ is handled exactly as Signal Handler.

The ManRiX Memory Manager is based in Mach’s VM design. The VM manager is divided into two parts, the machine dependent part called that Pmap and the machine independent part called the vmmap. This technique makes the portability easier to new architectures. MACH’s original VM system was designed on an object oriented manner. Its basic abstractions are represented by objects that are accessed by a well defined interface.

The highest level object is vm_map. A vmmap describes the virtual address space of a process or the kernel. It contains a list of valid mappings in the virtual address space and those mapping’s attributes. It holds a doubly linked list of vm_map_entries and a hint pointing to the last entry that resolved a page fault. Each vm_map_entry describes a contiguous region of virtual memory that has some protections. ManRiX Virtual Manager.

A vm_object represents a memory object. The memory object can be a set of physical pages or a memory mapped files. A vm_object describes a file, a zero-fill memory area, or a device that can be mapped into a virtual address space. The vm object contains a list of vm page structures that contain data from that object. The vm_page describes a page of physical memory. When the system is booted a vm page structure is allocated for each page of physical memory that can be used by the VM system.
The VM manager supports read/write sharing of memory and copy on write sharing of memory. The ManRiX VM manager uses a slab allocator (conceived by Solaris) to allocate kernel memory. following