Subversion Repositories HelenOS-doc

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
155 decky 1 
\chapter{Specification}
2 
 
3 
\section{Overall Conception}
4 
 
5 
General-purpose and portable operating system with elements of
6 
microkernel design and fully preemptive kernel.
7 
 
8 
SPARTAN kernel created by Jakub Jermar will be used as a basis for
9 
further kernel development.
10 
 
11 
Detailed description of the features:
12 
 
13 
\begin{itemize}
14 
 \item General-purpose: Ready to run standard (non real-time) server and
15 
       workstation applications. Support for common programming
16 
       abstractions (threads, synchronization, physical and virtual
17 
       memory management).
18 
 \item Portable: Except small platform-specific kernel parts the system
19 
       will be implemented in higher programming languages to be portable
20 
       to different hardware platforms (PCs and similar).
21 
 \item Fully preemptive kernel: The basic scheduling element will be a
22 
       thread (more threads eventually grouped into a task) and the task
23 
       switching will be preemptive in both user-space and kernel-space.
24 
       However no real-time scheduling will be attempted.
25 
 \item Fine grained locking in kernel: The kernel will not contain
26 
       anything such as "big kernel lock", all critical sections will be
27 
       handled with small granularity locking.
28 
 \item Elements of microkernel design: The code running in kernel-space
29 
       will be limited to a much smaller size compared for example to the
30 
       traditional Unix design. The kernel will contain mostly just the
31 
       code which is necessary to run in kernel-space (scheduling, memory
32 
       management and protection, hardware resource management, IPC).
33 
       Device drivers, filesystems, network stacks, etc. will be
34 
       implemented in user-space.
35 
\end{itemize}
36 
 
37 
\section[1a]{Research Domains}
38 
 
39 
Following features can be eventually implemented as research subjects,
40 
but are optional to the overall design of the system:
41 
 
42 
\begin{itemize}
43 
 \item Kernel-level virtualization: Apart from some standard security
44 
       model (i.e. unix-like or any other) the OS might support
45 
       kernel-level context separation allowing to run more virtual
46 
       operating environments on a single physical machine.
47 
 \item Framework for running GNU/Linux applications: There should be no
48 
       syscall or native API compatibility, but rather some kind of
49 
       compile-time layer (libc and other shared libraries) allowing to
50 
       compile common GNU/Linux applications from sources.
51 
 \item Object/message paradigm: In the contrary to Unix file paradigm
52 
       (where every object in the system is represented by a file - even
53 
       if there is no consistent mapping from the given object's methods
54 
       to generic file methods), HelenOS might have a tree of objects
55 
       instead of a tree of files. Each object in the tree can support an
56 
       arbitrary set of messages and files are those objects which
57 
       support the set of messages representing file methods (i.e. open,
58 
       close, read, write, seek, etc.). All objects might support several
59 
       compulsory messages (GetName, GetSupportedMessages, etc.). The
60 
       message passing mechanism will be synchronous.
61 
\end{itemize}
62 
 
63 
\section{Particular features}
64 
 
65 
\begin{itemize}
66 
 \item Kernel features
67 
       \begin{itemize}
68 
        \item Preemptive multiprocessing, SMP support, threads (tasks)
69 
              \begin{itemize}
70 
               \item Simple scheduler (but more complex than round-robin),
71 
                     with threads as basic scheduling element
72 
               \item Support for thread priorities (possibly classes of
73 
                     priorities for user-space tasks)
74 
               \item Support for SMP CPU bounding
75 
               \item Utilization of non-boot CPU(s)
76 
               \item Support for user-space threads (tasks as sets of
77 
                     threads)
78 
               \item Support for kernel threads (independent code executed
79 
                     within the kernel)
80 
              \end{itemize}
81 
        \item Kernel synchronization primitives, small granularity
82 
              synchronization (preemptive kernel)
83 
              \begin{itemize}
84 
               \item Semaphores, mutexes, condition variables, RW-locks,
85 
                     spin-locks, etc.
86 
               \item No "big kernel lock"
87 
              \end{itemize}
88 
        \item Physical and virtual memory management
89 
              \begin{itemize}
90 
               \item Proper handling of physical memory regions
91 
               \item Physical memory heap (allocating of continuous blocks of
92 
                     physical memory)
93 
               \item Arbitrary number of independent virtual memory mappings
94 
                     (both for threads and internal kernel usage)
95 
               \item Kernel allocator in virtual memory (buddy/slab)
96 
               \item Named (text, stack, heap) and unnamed virtual memory
97 
                     areas
98 
               \item Copying and sharing pages between different memory
99 
                     mappings
100 
              \end{itemize}
101 
        \item Basic hardware handling
102 
              \begin{itemize}
103 
               \item Handling of basic boot-time hardware (CPU, PCI buses,
104 
                     memory, display, keyboard, RTC, etc.) in kernel
105 
               \item Handling of specific hardware resources which are
106 
                     fundamentaly unreachable from user-space on given
107 
                     platform
108 
              \end{itemize}
109 
        \item IPC, user-space hardware access framework
110 
              \begin{itemize}
111 
               \item Abstraction for implementing inter-process communication
112 
                     (message passing, etc.)
113 
               \item Interface for enabling the user-space threads to gain
114 
                     access and manage hardware resources (with kernel
115 
                     modules where needed)
116 
              \end{itemize}
117 
       \item User-space features
118 
             \begin{itemize}
119 
              \item Basic API
120 
                    \begin{itemize}
121 
                     \item Memory management API (memory regions creation,
122 
                           descruction, resizing)
123 
                     \item Task/thread management API
124 
                     \item Synchronization API
125 
                    \end{itemize}
126 
             \end{itemize}
127 
     \end{itemize}
128 
\end{itemize}
129 
 
130 
\section{Implementation details}
131 
 
132 
\begin{itemize}
133 
 \item Supported platforms
134 
       \begin{itemize}
135 
        \item Real hardware support
136 
              \begin{itemize}
137 
               \item IA-32 (will be tested on multiple consumer Intel Pentium~4,
138 
                     Intel Pentium~M, AMD Athlon~XP and AMD Athlon~MP machines)
139 
               \item PowerPC (will be tested on a consumer IBM PowerPC G5 machine)
140 
              \end{itemize}
141 
        \item Emulated support
142 
              \begin{itemize}
143 
               \item MIPS (will be tested in MSIM R4000 simulator)
144 
               \item IA-64 (will be tested in Ski simulator)
145 
               \item AMD64 (will be tested in Simics simulator)
146 
              \end{itemize}
147 
       \end{itemize}
148 
\end{itemize}