The use of virtual memory practically eliminated the need for the contiguity of physical mem- ory allocation as physically discontiguous memory can be contiguous in the virtual address space. Unfortu- nately, avoiding performance degradation for memory- intensive workloads on modern CPUs requires a steady supply of contiguous physical memory, making external physical memory fragmentation in modern operating systems a serious issue once again.
This paper presents the design and implementation of several several anti-fragmentation mechanisms for the FreeBSD kernel. Parts of this work were sponsored by the Google Summer of Code ’23 program.
This presentation delves into the innovative integration of vector databases with ChatGPT, enriching the capabilities of the FreeBSD Expert System. The synergy of these technologies opens new avenues for intelligent, adaptive system administration tools.
Design Driven Development using the Spin Verifier.
The Problem: Currently, the NetBSD sources are inherited from historic research, and maintained by a small, but committed group of volunteers. Often, the role of the NetBSD developer is to implement or port the design and implementation of a research project, and this involves buildup of design understanding and interpretation within the memory of a few “experts” within the community. This poses a few problems, especially for newcomers to the project:
In this talk, I demonstrate DDD, compare it with industry’s “Model Based System Development” approaches, and show how the tech- nique may be used to help architects and developers (who may often be the same person), to separate concerns.
For architects, it takes off the burden of having to rely on their memory, random tests and bespoke models to keep state. For developers, it provides a clear ”source of truth” and a process based mechanism to verify their implementation based on this source. And for project managers, there’s much better visibility over the entire Q&A, analogous to but much more powerful than a simple TDD style development process.
Although UNIX’s descendants or derivatives are not hard real-time operating systems, some have support for soft real-time through allowing to assign to userland processes higher priorities normally reserved to the system, sometimes coupled with preemption of kernel tasks, making them suitable as a fundation of soft real-time system. POSIX standardized its first real-time extensions in 1993 in a document usually referred to as POSIX.1b. At that time, however, some operating systems already had support for soft real-time in the form of ad-hoc APIs, such as System V Release 4 (SVR4) with its priocntl(2) system call and HP/UX with its rtprio(2) one. FreeBSD first adopted its own rtprio(2) system call in 1994, largely based on HP/UX’s with extensions such as idle processes. POSIX.1b extensions concerning processes were implemented later, in 1998, and some preliminary thread support added the next year. Since then, these APIs have been present in the system for applications to use.
In this paper, we provide a thorough description of both FreeBSD’s rtprio(2) and POSIX.1b’s scheduling interfaces and embark on a journey around FreeBSD’s implementation of scheduling priorities. It started with a desire to fix a few apparently simple bugs of rtprio(2) and to add some reasonable features and, one thing leading to another, became an almost complete rewrite of this system call and the POSIX.1b’s interfaces’ implementations. We will expose the many problems that the current implementation has, in terms of POSIX compliance, security and consistency and how we are fixing them. As of this writing, this project is still a work in progress, and we will report about its status during the conference presentation.
DTrace and eBPF are today’s most potent observ- ability tools available on general-purpose operating systems. They empower users to ask random questions and receive complex answers about any part of the system. Their performance is unmatched by any traditional observability tools.
Unfortunately, their performance characteristics are not well- researched, partially because designing a benchmark to measure the measurement tool is challenging.
In this paper, we learn about the basics of art benchmarking and the importance and difficulties of operating system instru- mentation. We review three generations of observability tools to understand their design and implementation limitations. Finally, we design, implement, and conduct a microbenchmark and an application benchmark to peak into the enigmatic domain of DTrace and eBPF performance overhead.
This paper presents the high-level ideas behind kinst, a new DTrace provider available in FreeBSD, which enables tracing of arbitrary instructions and inline functions in the kernel.
This paper introduces the low level debugger (LLDB) kernel module debug facility for the FreeBSD kernel. The current functional status of LLDB within the FreeBSD kernel is attributed to contributions from [1] and the collaborative efforts of the community. Key functionalities include core dump parsing and memory context building for the coredump, specifically integrated into the process plugin within LLDB for the FreeBSD kernel. This enhancement equips LLDB for effective post-mortem debugging on the FreeBSD kernel. While the implementation of the process plugin has been successfully completed, the paper emphasizes the imperative need to implement the Dynami- cLoader plugin for the kernel loader. This plugin plays a critical role in loading the symbol file of the kernel module, ensuring comprehensive parsing of symbols for loadable kernel modules. Additionally, given the potential existence of the kernel module as either a relocatable file (for x86) or a shared object (for ARM), the implementation should confirms the usability of both types of ELF format kernel modules.