g4j2EmtV

1
2
3\documentclass[11pt]{IEEEtran}
4
5\documentclass[journal]{IEEEtran}
6
7%\usepackage[retainorgcmds]{IEEEtrantools}
8%\usepackage{bibentry}  
9\usepackage{xcolor,soul,framed} %,caption
10
11\colorlet{shadecolor}{yellow}
12% \usepackage{color,soul}
13\usepackage[pdftex]{graphicx}
14\graphicspath{{../pdf/}{../jpeg/}}
15\DeclareGraphicsExtensions{.pdf,.jpeg,.png}
16
17\usepackage[cmex10]{amsmath}
18%Mathabx do not work on ScribTex => Removed
19%\usepackage{mathabx}
20\usepackage{array}
21\usepackage{mdwmath}
22\usepackage{mdwtab}
23\usepackage{eqparbox}
24\usepackage{url}
25\usepackage{float}
26
27
28
29%\bstctlcite{IEEE:BSTcontrol}
30
31
32%TITLE & AUTHORS 
33\begin{document}
34\bstctlcite{IEEEexample:BSTcontrol}
35    \title{An Analytical Discussion of Monolithic Kernel Architectures}
36  \author{
37  Sherif Hisham Gabr 900183120,
38  Mina Ashraf Gamil 900182973
39      
40 
41 
42}
43
44
45% The paper headers
46\markboth{Assignment, NO.~1, February~2021
47}
48
49
50% ====================================================================
51\maketitle
52
53
54
55% === ABSTRACT 
56\begin{abstract}
57%\boldmath
58A kernel is the fundamental computer program at the core of an operating system that controls the computer's resources. The kernel can be structured in a number of ways, such as the monolithic structure, microkernel structure, or a hybrid of both. This paper provides an analytical discussion on the monolithic kernels. The paper explains the several advantages of monolithic kernels by providing internal details of such structures and comparing them to the other structures. The main focus, though, is on the most prevalent monolithic kernels in today's market like Linux, FreeBSD, and other smaller operating systems. In an attempt to explain why monolithic kernels still exist and widespread, the mentioned kernels are compared to other non-monolithic modern widely-used operating systems, such as Mac OS X and Windows 8. They are being compared based on speed and efficiency to execute system calls. Following the comparison, it can be concluded that monolithic kernels are faster than other types due to running all services in kernel space. However, it does come with a trade-off of hard maintainability and hard portability. Nevertheless, the monolithic kernels are used in many prominent products and still hold a high market share in the domain of the operating system.   
59\end{abstract}
60
61
62% === KEYWORDS ====================================================================
63% =================================================================================
64\begin{IEEEkeywords}
65Kernel, Operating System, Interrupts, System Calls, Interprocess Communication, Microkernel, Threads, Process
66\end{IEEEkeywords}
67
68
69
70
71
72\IEEEpeerreviewmaketitle
73
74
75
76
77
78
79\section{Introduction}
80
81\IEEEPARstart{T}he kernel is the core and the most important part of the operating system. Most operating systems are mainly separated into two different spaces: the kernel space, where applications run with higher privileges and with full access to the underlying hardware, and the userspace, or the unprivileged mode. According to this definition, kernel architectures can be categorized into two main categories: the monolithic kernel architecture and the microkernel architecture. Other architectures can be viewed as branches with minor deviations from these two types. Despite being the oldest of the two, the monolithic approach is the most widely used architecture in today's systems [1]. It is not only used in kernels of personal computers operating systems such as BSD, UNIX, Linux, and MS-DOS, but also in mainframe systems such as the famous z/TPF (transaction processing facility) designed by IBM for reliable high-volume transaction processing used by VISA and banks. The main feature of monolithic architectures is that they run all basic system services like interrupt handling, memory management, file system, and Input/Output communication inside the kernel space. The main advantages of the monolithic design are that the kernel is one static binary file and that all processes and services run under the same address space, which facilitates and speeds up the communication between them [2]. Also, performance speed is very good in monolithic architectures; this doesn't mean that the speed of fixing bugs or updating the system is going to be fast by any means. The first major drawback is the kernel size which is often huge and consumes a big chunk of the available memory. The second drawback is that the whole kernel should be recompiled again for each bug fixed and for each new feature added, which is a process that consumes a lot of time and resources. It is worth mentioning that the monolithic kernel is structured in a layered-fashion starting from the fundamental process management at the bottom, going all the way up to the libraries and applications [1].
82
83\begin{figure}[H]
84  \includegraphics[width=\linewidth]{monolithic structure.png}
85  \caption{Monolithic Structure.[3]}
86  \label{fig:Monolithic Structure}
87\end{figure}
88
89
90
91% === II. Background ========================
92% =================================================================================
93\section{Background}
94
95Before discussing the advantages and disadvantages of monolithic kernels, it is a must to understand the important distinctions between different kernel architectures.
96\subsection {Different kernel architectures}
97\subsubsection{Micro-kernels}
98
99The first computers' operating systems did not have kernels at all, but as time elapsed, OSes evolved to support more hardware, and the need for kernel-based operating systems grew. The micro-kernel is a minimal system kernel as they were very small in size to fit inside the limited memory of computers [2]. It didn't take long before computers became stronger and memory became abundant, and the shift to monolithic kernel had more advantages than disadvantages. Mainly, micro-kernels have functions needed to support inter-process communication, memory management, and scheduling [2]. The rest of the programs run in user-mode with the functionalities divided into smaller processes known as servers. Each of these servers has its own separate address space and can communicate together through "Message Passing". The main disadvantage is that there is a lot of overhead in this communication, and the frequent context switches slow down the system considerably [4].  
100\subsubsection{Monolithic kernels}
101\par
102Monolithic kernels are the main focus of this paper, so we shall keep the details to be discussed later in the paper. For now, one must recognize the fact that in monolithic kernels, there are more services and programs running together in kernel mode under the same address space. This includes the device drivers, the virtual memory management unit, and all inter-process communication, as well as the filesystem [1]. This removes the overhead of context switching for processes to communicate together. In other words, communication becomes as simple as function calls to other programs. This comes at a price; a single bug or error in any module has the ability to crash the whole system because the kernel is one big static binary that is always in the memory. Finally, it is important to mention that most operating systems nowadays use the monolithic kernel architecture such as the Linux-kernel, all BSD-derivatives like Free-BSD, MS-DOS, and Microsoft Windows 9x series. [2]
103\subsubsection{Hybrid kernels}
104
105Hybrid kernels can be viewed as the middle ground between the two design approaches. It was used by a lot of famous Operating systems such as the Windows NT series (including XP and Vista) and was used by Apple for its Max OS/2 and OS/X. Hybrid kernels run the IPC and the device drivers in kernel mode, while it uses the user-mode to run the UNIX-server, the file-server, and user applications. A famous example is the Mac OS that is based on the XNU kernel with MACH microkernel design and the monolithic BSD running on top of it. [5]
106\subsection{Important concepts for kernel design}
107\subsubsection{Interprocess communication}
108
109	One of the top comparison points between the monolithic architecture and the microkernel architecture is the performance speed, and the reason why the early implementations of microkernels were very slow is because of the multiple heavy context switching that happens to support the interprocess communication through message passing [1]. Thus, it becomes very important to understand how interprocess communication works? The first implementation of it used SIGNALS, which is still currently used by UNIX. Signals are predefined numerical constants that can be sent by the user, the OS, or another process to the signal handler that should be part of each process. Although this system is very fast, it is not easily modifiable as the signals must be previously defined and cannot be changed, or the process would behave unexpectedly. The newer solution was to use sockets and ports where each process binds itself to at least one socket and listens to it. The two communicating processes, known as servers and clients, are now not limited to using numbers for communication; this allows for much greater extensibility for communication as long as the server can understand the message received. These two systems were used by the monolithic kernels; however, the microkernels relied on a more powerful system despite being poorly implemented at first [1]. Microkernels used the system of message queues built as a FIFO (first-in-first-out). Moreover, this system doesn't limit each process to one message queue as they can have multiple message queues where each one is responsible for different types of messages.
110
111\subsubsection {Memory Management}
112
113
114As mentioned earlier, monolithic kernels implement all services inside the kernel space, including the memory management service. The management unit inside the kernel is responsible for the virtual memory management, the page replacement policy, and memory allocation for processes [2]. To understand the power of this system, it would be very useful to contrast it to the microkernels. The first generations of microkernels had the memory management units in the user space; on a page fault, the request had to go through the kernel, so the pager switched to kernel mode to access the memory and allocate it, then switch back to user mode. Then, it sends the result to the process that resulted in the page fault. Obviously, this process was very slow and inefficient. This was later fixed in the L4 implementation where each process had three management primitives: grant, map, flush, but if the process granted access of its pages to another process, it will no longer be able to access them unless it "flushes." [1]
115
116\begin{figure}[H]
117  \includegraphics[width=\linewidth]{monolithic structure 2.png}
118  \caption{Memory Monolithic Management.[1]}
119  \label{fig:Memory Monolithic Management}
120\end{figure}
121
122
123
124\subsubsection {I/O Communication}
125I/O communication is the way the operating system gets to understand the hardware and work dynamically with it. This happens through interrupts and their interrupt handlers. Since all device drivers are loaded inside the kernel space, hardware interrupts are handled directly by the kernel. This causes a similar problem to what was described above in terms of flexibility, as changes cannot be applied easily without changing the upper layers [1]. 
126This led to the birth of the concept of modular architectures to achieve independence and separation from the kernel as the modules could be loaded or unloaded during runtime. The only problem here is that this no longer ensured that newer kernels would work with the same device drivers. Thus, in some cases, if the changes inside the monolithic kernel were a lot, device drivers didn't only need binary recompilation but also device drivers source code modifications.
127
128
129
130
131
132
133\section{Discussion}
134
135Due to its high speeds compared to other approaches, it is no surprise that the monolithic ideology is still widely used. Even though there are not many pure monolithic products that exist nowadays, there are many vastly used products that follow the monolithic approach of residing core functionality and all system services in kernel space. However, they contain a feature of adding additional functions and services via modules without the need to recompiling the entire kernel, which would have been the case for pure monolithic kernels due to their high coupling. They are still considered monolithic because all functionalities, even modular ones, run from the kernel space. This notion of dynamic linking paved the way for the modern monolithic implementations and eliminated one major disadvantage the monolithic kernels had, which is that they are hard to modify [6]. 
136 
137
138The most prominent modern monolithic products include UNIX-based kernels like FreeBSD, Linux kernels, and Linux-based kernels like Android, DOS (Disk Operating System) like MS-DOS, and other not well-known systems. Monolithic systems hold a relatively high market share in the OS domain, as in figure 3. This is because of the vast numbers of mobile devices using Android as the operating system. 
139
140Although Android, a Linux-based mobile OS, as shown in figure 4, highly dominates in the Monolithic Market Share, the other monolithic products have different approaches that are worth discussing. In the following sections, we will discuss the internal details of FreeBSD and Linux.
141 
142 \begin{figure}[H]
143  \includegraphics[width=\linewidth]{market share.png}
144  \caption{OS Market Share.[7]}
145  \label{fig:OS Market Share}
146\end{figure} 
147
148
149\begin{figure}[H]
150  \includegraphics[width=\linewidth]{monolithic market share.png}
151  \caption{Monolithic Market Share.[7]}
152  \label{fig:Monolithic Market Share}
153\end{figure}
154
155\subsection {FreeBSD:}
156\par
157FreeBSD is one of the most prevalent operating systems that are based on a monolithic kernel. It uses a modular kernel similar to the famous UNIX monolithic kernel. This monolithic nature of the FreeBSD kernel allows for high speed and performance as kernel components can communicate together directly without any heavy context switching or message passing [8]. The communication between them happens seamlessly by utilizing direct procedure calls. FreeBSD also implemented the multithreaded process concept where every process keeps track of its threads in a linked list. Since threads are supposed to execute simultaneously, the FreeBSD kernel implemented the concept of variable-weight processes through the rfork() procedure. The kernel state of each process is separated into two different parts inside FreeBSD [5]. The first is the process structure, and it must be present in the memory at all times. The second is the thread structure which contains the information needed to run the process, such as the stack to use when executing, some scheduling information, and the thread state block.
158
159Although both Free-BSD and Linux kernel is monolithic and UNIX-like in terms of design, there are some minor differences that are important to mentions. Both kernels use different scheduling techniques that the differences are very significant. The Free-BSD kernel 7.0 was nearly 0.15 times better in MySQL than Linux [2]. They also differ in interrupt handling as the interrupt threads made locking inside the kernel easier. In terms of similarities, both kernels are very similar in the way they create processes and in their kernel synchronization and memory management [8].
160\subsubsection{BSD memory management}
161FreeBSD uses virtual memory and pages to organize its memory usage and to isolate processes from each other. In fact, FreeBSD implemented the usage of free-lists for data-structures inside the slab-layer before Linux, which later adopted the same technology. For page replacement, FreeBSD used least-recently-used (LRU) replacement algorithms and could swap a whole process out of memory if needed. It also used the page hash table instead of the radix-tree, which was famous at that time [8]. Radix trees are simple binary trees that allow fast searching for the desired virtual page. This means that FreeBSD had to look in a double-linked list in order to determine if a specific page was already cached or not because the buffer-cache is not separated from the page-cache [2]. 
162\subsubsection{BSD Kernel synchronization}
163The operating system has to make sure that only one process at most is using the same resource at each point in time. FreeBSD used the look mechanisms, atomic operations, mutexes to deal with this problem. Simply stated, a mutex is a spinlock that locks a resource for the process that claimed it first, and no other process can claim it until it is released by the locking process [8].
164\subsubsection{BSD interrupt handling}
165Interrupt threads is a scheme used by FreeBSD where it uses high-priority threads to handle interrupts, and it can block on a mutex. The FreeBSD kernel could also preempt a low priority interrupt by another one of higher priority [9].
166
167\subsection {Linux:}
168\par
169\subsubsection{Overview}
170\par
171Linux is one of the most popular operating systems in the world of computers. Linux uses a monolithic kernel architecture, but this didn't prevent it from being a well-structured kernel. Although Linux implemented the concept of modules to solve many of the disadvantages of Monolithic kernels, it is still basically and fundamentally a monolithic kernel with the support of multitasking. In Linux, each program or application is called a process, and it is given a virtual address, and it thinks it is the only process running [3]. If two processes want to communicate, then the special features of the kernel are deployed and used. To maintain concurrency, the kernel is responsible for context switching and saving all the states of a program before running another one quickly, so the user perceives they are running concurrently. The Linux kernel is also responsible for resource management and allocation, including time, so the kernel decides how much time is spent running which process. The more important a program is, the more time the kernel is going to spend running it [1].
172
173\begin{figure}[H]
174  \includegraphics[width=\linewidth]{linux structure.png}
175  \caption{Linux Structure.[3]}
176  \label{fig:Linux Structure}
177\end{figure}
178\\
179\subsubsection{Linux process management}
180Linux uses the process IDs to identify each running process. This process identifier is an integer but uses at most the length of the short data type, which is maxed at 32768 [2]. This is for back-compatibility with older UNIX and Linux versions. 
181Each process has one of five states:
182
183\begin{itemize}
184\item	Running: the task is either running or waiting in the Run-queue to be executed.
185\item INTERRUBTIBLE: The process is sleeping and waiting for a wake-up signal to continue execution.
186\item UNINTERRUBTILE: the process cannot be waked-up by a signal.
187\item ZOMBIE: the process has finished execution, but its parent has issued a wait4() system call to free its process descriptor
188\item STOPPED: the process has finished and cannot go back to the state of Running.
189
190\end{itemize}
191
192\subsubsection{Running new processes through forking}
193\par
194Linux uses a hierarchical process scheme where each process depends on its parent. The kernel first runs the init process, and every other process is a branch from this process. To do this, the Linux kernel uses the fork() and exec() mechanisms. Fork () creates an exact copy of the parent process but with a different process ID. Then exec is responsible for replacing the code in this new copy with the code from another binary to be executed [3].
195\par
196\\
197
198\subsubsection{Threads and shared memory}
199Linux also uses Threads, known as light-weight processes, to help increase the speed and concurrency. Threads share the same memory space as the main program, the data processed by them is already present in the main address space [3]. Therefore, there is no need to create communication between two different threads as they can access the same memory.
200\par
201\\
202\\
203\subsubsection{Privileged levels and switches to kernel mode}
204Moreover, Linux provides separation between user space and kernel space by preventing unprivileged users from accessing or manipulating memory in the kernel space [3]. This method also prevents processes from communicating together by changing the other process's data without knowing; this happens by limiting each process's memory access to its own allocated pages only. If a process wants to perform a task that requires access to the hardware, it has to switch to kernel mode, which happens through system calls [2]. 
205
206
207\subsubsection{System calls}
208
209Linux provides a set of system calls that allow user programs to interact with the kernel while providing a layer of abstraction to the programmer through the POSIX standards. In Linux, system calls are divided into six groups: process management, signals, files, directories and the file system, protection mechanisms, and finally, timer functions [3].
210
211\begin{itemize}
212\item	Process management: creating a new task, debugging, and collecting information about running processes.
213\item Signals: send signals, handle signals, timers. information about the filesystem.
214\item Files: open() files, close() files, create files, read() or write() to and from files. 
215\item Directories and the file system: cd into directories, create directories, or delete them.
216\item Protection mechanisms: handles namespaces, change and read user IDs or group IDs (UID and GID for file permissions)
217\item Timer functions: handling timer functions
218\end{itemize}
219
220\subsubsection{Linux modules and HotPlugging}
221\\
222The concept of modules provided a mechanism for dynamically adding or removing features from the kernel at runtime. Some examples of subsystems that can be modularized are: filesystem, networking protocols, device drivers, etc. modules can be viewed as normal programs that can run inside the kernel space, but they must have an init and terminate sections that define what exactly should be done once you load and terminate each module. [2] 
223An important feature of modern computers that is made easier through modules is HotPlugging. Once the system detects a new plugged-in device, it will locate its device drivers and load them into the kernel. This enabled the kernel size to be shrunk extremely as it is no longer bloated by unnecessary and unneeded device drivers that it may never use. [3]
224
225
226
227
228\section{Analysis}
229
230Monolithic architecture has been around for so long now, and it is still widely used nowadays. As we have previously seen, the monolithic approach does indeed have many advantages along with many disadvantages, so why do people still use and maintain monolithic kernels. To answer this question, we need to compare monolithic kernels to other kernel architectures like the microkernel and hybrids and see where both fail and succeed. 
231 
232Linux was developed by Linus Torvalds in the early 1990s as a replacement for the many shortcomings of the microkernel educational operating system called MINIX. At that time, writing monolithic kernels was considered obsolete and a giant setback, as microkernels were just emerging [10]. However, Linus insisted on developing Linux as a monolithic kernel for many reasons and for the many limitations the new technology, microkernels, had. Linus stated that "MINIX doesn't do the microkernel thing very well, and has problems with real multitasking" [10]. Another major advantage it had over MINIX is that Linux was capable of a multithreaded file system, a feature that is considered a performance hack on microkernels [10]. However, due to its monolithic design, one major drawback Linux had was portability. It was hard to port Linux to the majority of hardware. It was considered an acceptable trade-off for a much simpler design. Nevertheless, Linux adhered to the POSIX standard. The fact that people cared for speed and memory more than future state-of-the-art design made Linux acceptable by normal people. As time went on, Linux began adding modules to the kernel, allowing for easier modifications and portability.    
233 
234Now, comparing Linux to more modern and advanced operating systems, Linux still holds up a great fight.  Mac OS uses the xnu "xnu not UNIX" kernel, which consists of a modified Mach microkernel design with a layer of BSD functionalities on top of the Mach infrastructure [5]. Therefore, Mac OS is considered a hybrid design. This way, it reduces the many drawbacks of message passing in the microkernel design. However, while comparing time to execute system calls of Linux kernel version 4.4.76-1 and FreeBSD, another monolithic operating system, with Mac OS X, Linux and FreeBSD outshined Mac OS in almost all benchmarks, especially when it comes to process creation (fork) and execution of binary image (execl), sometimes up to 6 times faster. See source [5] for more details. 
235 
236Another widely used operating system, the Windows OS, used to follow a pure microkernel architecture; however later versions opted for a hybrid design by moving the components designed to operate in user mode back into kernel space because of poor performance [9]. Comparing Linux to Windows 8 and other UNIX-based monolithic operating systems like FreeBSD and Solaris, Linux has better overall performance because of its highly optimized services implementation and its proximity to the hardware [9]. Out of all OSes compared, Windows was relatively the slowest in the benchmarks with pthread library; check figure 6. The downside to Windows is that it imposes layers between the hardware and userspace, hindering performance. FreeBSD and Solaris shared similar approaches to handling the low-level design of process structures [9].
237\\
238\\
239 \begin{figure}[H]
240  \includegraphics[width=\linewidth]{table .png}
241  \caption{Benchmarks with the pthread library (user and system time in secs).[9]}
242  \label{fig:Benchmarks with the pthread library}
243\end{figure} 
244
245Since Linux is one the fastest kernels that exists, it is being used in some of the world's most crucial markets. Linux is used to perform functionalities and run servers of big companies like Google, Oracle, NASA, CERN, several defense departments, and many others. 
246
247The most notable use of Linux is its inclusion in Android, leading in the mobile OS market by a large margin. Since Android is open source available for any manufacturer to use, it shows no signs of slowing down in its domination. Google uses the Linux kernel as the backbone of Android and ChromeOS [11]. Also, Linux is used by Google to run server-end machines and employees' work desktops.
248
249Another major contribution Linux has is in the scientific field. NASA is known to operate using Linux machines; even the Perseverance Rover, which landed on Mars in February 2021, had a Linux computer on board [12]. Another major organization using a combination of monolithic kernels, especially Linux, is CERN, European Organization for Nuclear Research. It takes advantage of Linux's fast speed and reliability to process, compute, and manage petabytes of data per month [13].   
250
251\section{Conclusion}
252Even though the notions of kernel development have not seen major development recently, they are still widely used, contributing to many fields. The monolithic approach is one such notion of kernel development. Its efficient approach towards handling system functions, such as inter-process communication, memory management, and I/O communications, in kernel space, makes it relevant till today. Their speed mainly relies on the idea that system services directly communicate together in the same address space. The most prevalent monolithic kernels are the Linux kernel and FreeBSD. They started out as pure monolithic kernels, therefore they were hard to modify and debug. As operating systems became more complex and therefore required a much bigger kernel, there was a need for modularity, especially when considering loading the entire kernel into memory. Consequently, modern monolithic kernels began adopting dynamic linking for modules. Needed and unneeded functionalities can be loaded and unloaded, respectively, during runtime without the need to recompile the entire kernel. This modularity made monothetic kernels able to compete with new emerging kernel architectures like microkernels and hybrid models. Till this day, monolithic kernels like Linux and FreeBSD are faster than hybrid operating systems like macOS and Windows. Its notable speed definitely reflects on its market share. Many big companies rely on monolithic OSes like Linux in many of their products and services that millions if not billions of people use on a regular basis, a prominent example is Android. \\
253As an end-note, it worth highlighting that each kernel development method does come with its advantages and its disadvantages. As this domain evolves, new approaches can be introduced to benefit from the speed of the monolithic kernels and the portability of microkernel systems.
254
255 \\
256
257\section{References Cited}
258
259[1] Roch, B., 2007. n. Monolithic kernel vs. Microkernel. [online] Available at: http://www.vmars.tuwien.ac.at/ courses/akti12/journal/04ss/ article_04ss_Roch.pdf\\
260
261[2] Bitterling, P. "Operating System Kernels." https://core.ac.uk/display/21273886, 2010 \\
262
263[3] W. Mauerer, Professional Linux Kernel Architecture. Somerset: Wiley, 2010. \\
264
265[4] K. Gos and W. Zabierowski, "The Comparison of Microservice and Monolithic Architecture," 2020 IEEE XVIth International Conference on the Perspective Technologies and Methods in MEMS Design (MEMSTECH), 2020. \\
266
267[5] S. Papadimitriou and L. Moussiades, "Mac OS versus FreeBSD: A comparative evaluation," Computer, vol. 51, no. 2, pp. 44–53, 2018. .\\
268
269[6] J.-M. de Goyeneche and E. Sousa, "Loadable Kernel Modules," IEEE Softw., vol. 16, pp. 65–71, 1999. \\
270
271[7] “Operating System Market Share Worldwide,” StatCounter Global Stats, Jan-2021. [Online]. Available: https://gs.statcounter.com/os-market-share. [Accessed: 27-Feb-2021]. \\
272
273[8] M. K. Maikasike, M. K. McKusick, G. V. Nier, and G. V. Neville-Neil, FreeBSD cao Zuo xi tong she ji yu shi xian: Ying wen ben = The design and implementation of the FreeBSD operating system. Beijing: Zhong guo dian li chu ban she, 2008. .\\
274
275[9] S. Papadimitriou and L. Moussiades. "A comparative evaluation of core kernel features of the recent Linux, FreeBSD, Solaris and Windows operating systems", 2016.\\
276
277[10] "Open Sources: Voices from the Open Source Revolution," O'Reilly Media - Technology and Business Training, 29-Mar-1999. [Online]. Available: https://www.oreilly.com/openbook/opensources/book/appa.html. \\
278
279[11] "Kernel : Android Open Source Project," Android Open Source Project, 01-Sep-2020. [Online]. Available: https://source.android.com/devices/architecture/kernel. [Accessed: 27-Feb-2021]. \\
280
281[12] M. Kan, "Linux Is Now on Mars, Thanks to NASA's Perseverance Rover," PCMAG, 19-Feb-2021. [Online]. Available: https://www.pcmag.com/news/linux-is-now-on-mars-thanks-to-nasas-perseverance-rover. [Accessed: 27-Feb-2021]. \\
282
283[13] S. Bhartiya, "How CERN Is Using Linux and Open Source," Linux.com, 24-May-2018. [Online]. Available: https://www.linux.com/topic/open-source/how-cern-using-linux-open-source/. [Accessed: 27-Feb-2021]. \\
284
285[14] S. Biggs, D. Lee, and G. Heiser, "The Jury Is In," Proceedings of the 9th Asia-Pacific Workshop on Systems, 2018. \\
286
287[15] Shropshire, J., 2014. Analysis of Monolithic and Microkernel Architectures: Towards Secure Hypervisor Design. 2014 47th Hawaii International Conference on System Sciences,. \\
288\end{document}
289
290
291