Monolithic Kernel Research Articles

Microkernel vs Monolithic Kernel Design Trade-offs

Abstract - In the operating system, there are different kernels, but in this paper, we will discuss two kernels: monolithic kernel and microkernel. Monolithic kernels are a bit risky in that they have everything like all in an imagined operating system which has a large amount of code that contains all the essential components like memory management and file handling monolithic kernels have direct access to everything if there is an issue entire system will be collapsed. Microkernels are like organised toolboxes with different components of each tool. In microkernel they are divided into parts like one handle memory and other handles files by dividing like this they mess with each other, and security also improves. The research includes a literature review that consists of the pros and cons of the two monolithic kernels kernel pros are easy to understand it is like one tool that gives you all the information and another is its efficiency everything will be together with less fuss. its like having all your required tools in one place. Cons they are inflexible. You can't swap out tools or make changes easily. They are risky if something goes wrong, it will affect the entire system. Microkernel Pros Dependability If one of the components misbehaves it won't mess with the other components.it is like a firewall between them. security they are divided into small. components mean fewer vulnerabilities. It is like locking each component securely. Cons performance in microkernels the components are divided into small categories due to this there will be extra communication between components it's like sending a component back and forth to another one complexity managing all these separate components and they can be arranged in a puzzle and it is worth for the security. In summary, monolithic kernels offer simplicity and efficiency but lack flexibility. Microkernels prioritise dependability and security.

Improving monolithic kernel security and robustness through intra-kernel sandboxing

The structure of commodity operating systems kernels remains largely unchanged despite radical changes in underlying hardware and security risks. Existing research has managed to increase overall monolithic kernel security using various defense mechanisms, such as kernel control-flow integrity, and through the use of active vulnerability discovery techniques such as system call fuzzing. However, these mitigation mechanisms often focus on a class of vulnerabilities while failing to address the broader, underlying architectural issues which amplify the impact of these issues.This paper presents a novel architectural approach that aims to increase the robustness and security of monolithic operating system kernels. We propose an operating system model which focuses on strict decomposition and runtime separation between individual monolithic kernel subsystems through separate execution contexts. We propose a novel, SMP-capable nested kernel architecture that enforces separation policies in an effective, efficient and mechanism-agnostic manner, complemented by a special compiler pass and a domain-specific language that provides a handy and intuitive way of specifying separation policies and automating their integration.We implement a prototype system based on the FreeBSD operating system and the Clang/LLVM compiler. We run a series of intense benchmarks to evaluate our model and separation mechanisms.

Big-Sensor-Cloud Infrastructure: A Holistic Prototype for Provisioning Sensors-as-a-Service

The proposed work relates to the development of Big-Sensor-Cloud Infrastructure (BSCI) that enhances the usability and management of the physical sensor devices. Traditional sensor networks are manufactured in a proprietary, vendor-specific design, and cannot handle application switching dynamically at runtime due to the presence of monolithic kernel. Thus, the applications are inaccessible to the common people who do not own physical sensor devices. Recently, sensor-cloud infrastructure has been viewed as a substitute for traditional sensor networks. However, with the increasing growth in the velocity, variety, and variability of data, the management becomes a serious concern and difficulty. Thus, existing systems are not able to capture, analyze, and control the present data efficiently, in real-time. BSCI is a distributed framework for Big sensor-data storage, processing, virtualization, leveraging, and efficient remote management. The framework interfaces between the physical and cyber worlds, thereby acquiring real-time data from the physical WSNs into the cloud platform. This data are processed and delivered to the end-users as a simple service - Sensors-as-a-Service (Se-aaS). Multiple organizations with heterogeneous demand can be successfully served with Se-aaS. From a user-perspective, BSCI allows the naive users to envision the typical sensor devices as simple accessible services like electricity, and water.

Enabling Efficient Fast Convolution Algorithms on GPUs via MegaKernels

Modern Convolutional Neural Networks (CNNs) require a massive amount of convolution operations. To address the overwhelming computation problem, Winograd and FFT fast algorithms have been used as effective approaches to reduce the number of multiplications. Inputs and filters are transformed into special domains then perform element-wise multiplication, which can be transformed into batched GEMM operation. Different stages of computation contain multiple tasks with different computation and memory behaviors, and they share intermediate data, which provides the opportunity to fuse these tasks into a monolithic kernel. But traditional kernel fusion suffers from the problem of insufficient shared memory, which limits the performance. In this article, we propose a new kernel fusion technique for fast convolution algorithms based on MegaKernel. GPU thread blocks are assigned with different computation tasks and we design a mapping algorithm to assign tasks to thread blocks. We build a scheduler which fetches and executes the tasks following the dependency relationship. Evaluation of modern CNNs shows that our techniques achieve an average of 1.25X and 1.7X speedup compared to cuDNN's two implementations on Winograd convolution algorithm.

How to Fillet a Penguin: Runtime Data Driven Partitioning of Linux Code

In many modern operating systems (OSs), there exists no isolation between different kernel components, i.e., the failure of one component can affect the whole kernel. While microkernel OSs introduce address space separation for large parts of the OS, their improved fault isolation comes at the cost of performance. Despite significant improvements in modern microkernels, monolithic OSs like Linux are still prevalent in many systems. To achieve fault isolation in addition to high performance and code reuse in these systems, approaches to move only fractions of kernel code into user mode have been proposed. These approaches solely rely on static code analyses for deciding which code to isolate, neglecting dynamic properties like invocation frequencies. We propose to augment static code analyses with runtime data to achieve better estimates of dynamic properties for common case operation. We assess the impact of runtime data on the decision what code to isolate and the impact of that decision on the performance of such “microkernelized” systems. We extend an existing tool chain to implement automated code partitioning for existing monolithic kernel code and validate our approach in a case study of two widely used Linux device drivers and a file system.

Mac OS versus FreeBSD: A Comparative Evaluation

FreeBSD (an open source Unix-like OS) and Apple’s Mac OS use similar BSD functionality but take different approaches. FreeBSD implements a traditional compact monolithic Unix kernel, whereas Mac OS builds the BSD Unix functionality on top of the Mach microkernel. The authors provide an in-depth technical investigation of both approaches.

Domain Isolated Kernel: A lightweight sandbox for untrusted kernel extensions

Monolithic kernel is one of the prevalent configurations out of various kernel design models. While monolithic kernel excels in performance and management, they are unequipped for runtime system update; and this brings the need for kernel extension. Although kernel extensions are a convenient measure for system management, it is well established that they make the system prone to rootkit attacks and kernel exploitation as they share the single memory space with the rest of the kernel. To address this problem, various forms of isolation (e.g., making into a process), are so far proposed, yet their performance overhead is often too high or incompatible for a general purpose kernel. In this paper, we propose Domain Isolated Kernel (DIKernel), a new kernel architecture which securely isolates the untrusted kernel extensions with minimal performance overhead. DIKernel leverages hardware-based memory domain feature in ARM architecture; and prevents system manipulation attacks originated from kernel extensions, such as rootkits and exploits caused by buggy kernel extensions. We implemented DIKernel on top of Linux 4.13 kernel with 1500 LOC. Performance evaluation indicates that DIKernel imposes negligible overhead which is observed by cycle level microbenchmark.

Тесты на константные неисправности как веб-сервис

In this paper, we tell about a web-service we would like to develop. There are two goals we aim at, when developing this service. The first one is to give researchers a platform, where they could conduct preliminary experiments with different methods of test generation for digital circuits, in order to check different ideas. The second one is an opportunity to share implementations of new developed methods “on-the-fly”. The web-service development procedure was splitted into three stages: the architecture design, a light version implementation and the actual implementation. This paper tells about first two stages. There are two types of web-service architectures - with monolithic kernel and with microkernel - and our architecture has the properties of both types. The intention was to have monolithic kernel, since the desired functionality is not that hard to implement. However, the property of being extensible by implementations of new methods implies that part of the functions (namely the methods implementations) should be designed as separate sub-services. The light version implementation was done for the only method: method of fault domain enumeration for the stuck-at-faults fault model. It proved that the designed architecture is viable. However, some issues with the architecture were discovered. A mechanism of on-the-fly deployment of a new method is unclear, since it is not obvious, how to satisfy possible dependences of the implementation. Also, the architecture does not follow the classical web-service design: the service has states, that should not be, if a service is intended to be the classical one. The resolution of these issues is left for the future.

Nested Kernel

Monolithic operating system designs undermine the security of computing systems by allowing single exploits anywhere in the kernel to enjoy full supervisor privilege. The nested kernel operating system architecture addresses this problem by "nesting" a small isolated kernel within a traditional monolithic kernel. The "nested kernel" interposes on all updates to virtual memory translations to assert protections on physical memory, thus significantly reducing the trusted computing base for memory access control enforcement. We incorporated the nested kernel architecture into FreeBSD on x86-64 hardware while allowing the entire operating system, including untrusted components, to operate at the highest hardware privilege level by write-protecting MMU translations and de-privileging the untrusted part of the kernel. Our implementation inherently enforces kernel code integrity while still allowing dynamically loaded kernel modules, thus defending against code injection attacks. We also demonstrate that the nested kernel architecture allows kernel developers to isolate memory in ways not possible in monolithic kernels by introducing write-mediation and write-logging services to protect critical system data structures. Performance of the nested kernel prototype shows modest overheads: <1% average for Apache and 2.7% for kernel compile. Overall, our results and experience show that the nested kernel design can be retrofitted to existing monolithic kernels, providing important security benefits.

Nested Kernel

Monolithic operating system designs undermine the security of computing systems by allowing single exploits anywhere in the kernel to enjoy full supervisor privilege. The nested kernel operating system architecture addresses this problem by "nesting" a small isolated kernel within a traditional monolithic kernel. The "nested kernel" interposes on all updates to virtual memory translations to assert protections on physical memory, thus significantly reducing the trusted computing base for memory access control enforcement. We incorporated the nested kernel architecture into FreeBSD on x86-64 hardware while allowing the entire operating system, including untrusted components, to operate at the highest hardware privilege level by write-protecting MMU translations and de-privileging the untrusted part of the kernel. Our implementation inherently enforces kernel code integrity while still allowing dynamically loaded kernel modules, thus defending against code injection attacks. We also demonstrate that the nested kernel architecture allows kernel developers to isolate memory in ways not possible in monolithic kernels by introducing write-mediation and write-logging services to protect critical system data structures. Performance of the nested kernel prototype shows modest overheads: <1% average for Apache and 2.7% for kernel compile. Overall, our results and experience show that the nested kernel design can be retrofitted to existing monolithic kernels, providing important security benefits.

Particulars of the Behavior Under Irradiation of Dispersion Fuel Elements with the Uranium Dioxide + Aluminum Alloy Fuel Composition

A fuel with the uranium dioxide + aluminum alloy composition was developed for fuel elements to be used in floating power-generating units and small nuclear power plants. Designs, fabrication technologies, and methods of monitoring cermet fuel elements of different standard sizes with an aluminum matrix and cladding comprised of zirconium alloys were developed at the Bochvar All-Russia Research Institute for Inorganic Materials. A complex of pre-reactor and reactor tests and post-reactor studies of fuel elements was conducted; it was shown that cermet fuel elements are promising. The particulars of the behavior under irradiation of fuel elements with the uranium dioxide + aluminum alloy fuel composition were determined. The high priority of developing floating power-generating units and small nuclear power plants is determined by economic expediency and the prospects for their use in regions which are difficult to access. A floating nuclear power plant is an autonomous power-generating object, which is built in a ship-building plant as a nonpowered vessel and then towed by sea or river to its site of operation. The core of such a power plant must meet enhanced requirements in terms of maneuverability, reliability, and safety under normal and emergency conditions. These requirements can be met by using tested ship technologies to design the core. The leading floating power-generating unit Akademik Lomonosov equipped with a KLT-40S reactor plant, a prototype of which is the setup used on operating nuclear-powered ships, will be positioned in Pevek for a practical demonstration of this technology. The fuel elements are being developed by modernizing the fuel elements used in nuclear icebreakers based on tested designs and technologies. One of the main requirements of fuel elements is the use of fuel with enrichment not exceeding 20%. The fuel composition of the fuel elements used in nuclear icebreakers cannot supply the uranium load needed to meet this requirement. The uranium concentration in the fuel composition based on uranium dioxide in an aluminum matrix (cermet fuel) is approximately two times higher, which makes it possible to meet the indicated requirement [1‐4]. Fuel elements with two designs with cermet fuel, cylindrical shape, and cladding made from the zirconium alloy E-110 were developed for the core of the leading floating power-generating unit: a fuel element with a monolithic kernel (monolithic fuel element) and with a kernel having a cavity of prescribed size, which is located at the center of the fuel element and oriented along the longitudinal axis and is intended to compensate for the radiation swelling of the fuel composition.

The Software Architecture for Efficient Distributed Interprocess Communication in Mobile Distributed Systems

The mobile distributed computing applications execute in heterogeneous and dynamic network environments and require efficient as well as reliable interprocess communication (IPC) mechanism. In general, the kernel-level IPC mechanisms offer improved performance as compared to middleware-based systems. This paper proposes the design and implementation of composite software architecture within monolithic kernel to realize high-performance and reliable mobile distributed IPC mechanism supporting mobile computing applications in heterogeneous and dynamic network environments. The performance of software architecture is measured in geographically distributed computing systems executing mobile computing applications. The experimental results illustrate that the proposed software architecture offers significantly improved performance in Ethernet (629 μs/25 Byte ~ 2929 μs/5 KB) as well as in wireless networks (34528 μs/25 Byte ~ 42511 μs/5 KB). The architecture successfully reduces distributed IPC latency in Ethernet (0.899 μs/Byte) and in wireless networks (92.628 μs/Byte). The comparative analysis illustrates that the composite architecture achieves performance enhancements in the range of 12.73 % to 75.84 % as compared to middleware-based IPC mechanisms. The proposed composite software architecture does not require any specific network topology and any specialized communication hardware.

Multicore Dynamic Kernel Modules Attachment Technique for Kernel Performance Enhancement

Traditional monolithic kernels dominated kernel structures for long time along with small sized kernels,few hardware companies and limited kernel functionalities. Monolithic kernel structure was not applicable when the number of hardware companies increased and kernel services consumed by different users for many purposes. One of the biggest disadvantages of the monolithic kernels is the inflexibility due to the need to include all the available modules in kernel compilation causing high time consuming. Lately, new kernel structure was introduced through multicore operating systems. Unfortunately, many multicore operating systems such as barrelfish and FOS are experimental. This paper aims to simulate the performance of multicore hybrid kernels through dynamic kernel module customized attachment/ deattachment for multicore machines. In addition, this paper proposes a new technique for loading dynamic kernel modules based on the user needs and machine capabilities.

Research in the Workflow Engine Based on Micro Kernel

With the analysis of existing workflow engine based on monolithic kernel, a workflow engine which is based on micro kernel is designed. Service implementation and activity scheduling are separated by the engine, and then the micro kernel layer is independent and stable. All this decreased cost of engine reconstruction and difficulty of maintenance; the engine is constructed by component-based development techniques and finite state machine, which reduce the coupling between system components and increase the flexibility of workflow engine.

리눅스 기반의 사용자 수준 플래시 파일 시스템의 구현

The number of applications of small embedded systems such as PDAs, electronic note books, etc. based on Kinux, have increased. Due to the monolithic characteristic of Linux kernel, it is not suitable to satisfy the various kinds of embedded application requirement. To assist the shortcoming of monolithic kernel, we implement uJFFS 113th file system as an application program process which runs in user space. This solution consists of a file system and a flash device driver, and makes Linux kernel smaller by separating the file system from the kernel. uJFFS consists of ujffs_fs that plays a part of file system and ujffs_drv that controls a flash device. Which provides the same user interface as Linux does. A Device driver for the physical device is implemented in user pace, which prevents kernel failures from file system errors. So uJFFS can increase stability of the system.

Fault-tolerant servers for the RHODOS system

Providing reliable services is one of the primary goals in designing a distributed operating system. Nowadays, we have seen a trend in distributed operating system design to shift from large kernel architectures or even monolithic architectures to microkernel architectures supported by the client/server model. This means that a lot of services of an operating system originally provided by the monolithic kernel are moved out of the kernel, forming individual servers. It is then crucial to guarantee that these servers will provide reliable services. This article describes a design, based on a twin-servers model, of fault-tolerant servers for the microkernel-based RHODOS distributed operating system. A model that supports fault-tolerant services is designed. The performance of the model is simulated and analyzed. A design that implements the model in the RHODOS environment is also outlined.

Architectural issues in microkernel-based operating systems: the Chorus experience

An important trend in operating system development is the restructuring of the traditional monolithic operating system kernel into independent servers running on top of a minimal nucleus or ‘microkernel’. This approach arises out of the need for modularity and flexibility in managing the ever-growing complexity caused by the introduction of new functions and new architectures. In particular, it provides a solid architectural basis for distribution, faulttolerance and security. Microkernel-based operating systems have been a focus of research for a number of years, and are now beginning to play a role in commercial UNIX ∗ ∗ UNIX is a trademark of UNIX Systems Labs, Inc systems. The ultimate feasibility of this attractive approach is not yet widely recognized, however. A primary concern is efficiency: can a microkernel-based modular operating system provide performance comparable to that of a monolithic kernel when running on comparable architectures? The elegance and flexibility of the client-server model may exact a cost in message-handling and context-switching overhead. If this penalty is too great, commercial acceptance will be limited. Another pragmatic concern is compatibility: in an industry relying increasingly on portability and standardization, compatible interfaces are needed not only at the level of application programs, but also for device drivers, streams modules and other components. In many cases, binary as well as source compatibility is required. These concerns affect the structure and organization of the operating system. The Chorus team has spent the past six years studying and experimenting with UNIX ‘kernelization’ as an aspect of its work in distributed and real-time modular systems. Aspects of the current Chorus † † Chorus is a registered trademark of Chorus systèmes. system are examined here in terms of its evolution from the previous version. The focus is on pragmatic issues such as performance and compatibility, as well as considerations of modularity and software engineering.