Mach 3 Kernel Principles

Mach 3 Kernel Principles Open Software Foundation and Carnegie Mellon University Keith Loepere O S F NORMA-MK12: July 15, 1992 This book is in the Open Software Foundation Mach 3 series. Books in the OSF Mach 3 series: Mach 3 Kernel Principles Mach 3 Kernel Interfaces Mach 3 Server Writer’s Guide Mach 3 Server Writer’s Interfaces Revision History: Revision 2 MK67: January 7, 1992 OSF Mach release Revision 2.2 NORMA-MK12: July 15, 1992 Change bars indicate changes since MK67. Copyright© 1991 by the Open Software Foundation and Carnegie Mellon University. All rights reserved. Contents CHAPTER 1 Introduction . 1 Kernel Abstractions . 2 Structure of this Document . 5 CHAPTER 2 Architectural Model. 7 Elements. 7 Threads. 10 Tasks . 10 Ports . 11 Messages . 11 Message Queues. 12 Port Rights . 12 Port Name Space . 12 Port Sets . 13 Virtual Address Spaces . 13 Abstract Memory Objects . 14 Memory Cache Objects . 15 Processors . 15 Processor Sets . 15 Nodes . 16 Hosts . 16 Devices. 16 Events. 17 CHAPTER 3 Threads and Tasks . 19 Threads. 19 Tasks . 24 CHAPTER 4 Ports, Rights and Messages. 27 Ports . 27 Messages . 29 Message Queues. 30 Port Rights . 30 Port Name Space . 32 Port Sets . 34 Message Transmission . 35 Mach 3 Kernel Principles iii CHAPTER 5 Virtual Memory Management . 37 Virtual Address Spaces . 37 Memory Objects. 40 CHAPTER 6 Physical Resource Management . 55 Physical Memory . 55 Processors . 56 Processor Sets . 57 Nodes . 59 Hosts . 60 Devices. 61 Access to Privileged Ports . 64 iv Mach 3 Kernel Principles CHAPTER 1 Introduction This book documents the user visible architecture of the Mach 3 kernel. It is assumed that the reader is familiar with the basic ideas of Mach as are found in: Mike Accetta, Robert Baron, William Bolosky, David Golub, Richard Rashid, Avadis Tevanian, Michael Young, “Mach: A New Kernel Foundation for UNIX Development,” in Proceedings of the Summer 1986 USENIX Conference, Atlan- ta, GA. The notion of operating system functionality provided via a Mach user space server can be found in: David Golub, Randall Dean, Alessandro Forin, Richard Rashid, “UNIX as an Application Program,” in Proceedings of the Summer 1990 USENIX Confer- ence, Anaheim, CA. Mach was originally developed as a variant of BSD that provided users with enhanced memory management, multiple points of control (threads) and an extensive process (task) to process communication facility (IPC). The goals of Mach include: • Exploiting parallelism in both operating system and user applications. • Supporting large, potentially sparse address spaces with flexible memory sharing. • Allowing transparent network resource access. • Compatibility with existing software environments (BSD). • Portability. The Mach 3 kernel is a kernel that provides only the Mach related features, along with any features needed to provide support for higher system layers. As such, the kernel no longer provides BSD functionality; indeed, it does not provide the functionality of any Mach 3 Kernel Principles 1 Introduction traditional operating system. Instead, it provides the base upon which operating systems can be built. The Mach kernel subscribes to the philosophy of: • A simple, extensible communication kernel. • An object basis with communication channels as object references. • A client / server programming model, using synchronous and asynchronous inter-process communication. • User mode tasks performing many traditional operating system functions (e.g. file system, network access). The fundamental idea is that of a simple, extensible communication kernel. It is a goal of the Mach project to move more and more functionality out of the kernel, until everything is done by user mode tasks communicating via the kernel. Of course, even in the ex- treme, the kernel must provide other support besides task to task communication, in par- ticular: • Management of points of control (threads). • Resource assignment (tasks). • Support of address spaces for tasks. • Management of physical resources (physical memory, processors, device channels). Even here, though, the goal is to move functionality outside the kernel. User mode tasks implement the policies regarding resource usage; the kernel simply provides mechanisms to enforce those policies. Kernel Abstractions Although it is a goal of the Mach kernel to minimize abstractions provided by the kernel, it is not a goal to be minimal in the semantics associated with those abstractions. As such, each of the abstractions provided has a rich set of semantics associated with it, and a complex set of interactions with the other abstractions. Although this makes it difficult to identify key ideas, the main kernel abstractions are considered to be the following: • Task — The unit of resource allocation: large address space, port rights. • Thread — The unit of CPU utilization, lightweight (low overhead). • Port — Communication channel, accessible only via send / receive capabilities (rights). • Message — Typed collection of data objects. • Memory object — Internal unit of memory management. The kernel provides some memory management, of course. Memory is associated with tasks. Memory objects are the means by which tasks take control over memory management. 2 Mach 3 Kernel Principles Kernel Abstractions Tasks and Threads The Mach kernel does not provide the traditional notion of the process. This is for two main reasons: • Any given operating system environment has considerable semantics associated with a process (such as user ID, signal state, etc.). It is not the purpose of the Mach kernel to understand or provide these extended semantics. • Many systems (BSD, for example) equate a process with an execution point of control. Some systems (AOS, for example) do not. Mach wishes to support multiple points of control in a way separate from any given operating system environment’s notion of process. Instead, Mach provides two notions: the task and the thread. A thread is Mach’s notion of the point of control. A task exists to provide resources for its containing threads. This split is made to provide for parallelism and resource sharing. A thread: • Is a point of control flow in a task. • Has access to all of the elements of the containing task. • Potentially executes in parallel with other threads, even threads within the same task. • Has minimal state for low overhead. A task: • Is a collection of system resources. These resources, with the exception of the address space, are referenced by ports. These resources may be shared with other tasks if rights to the ports are so distributed. • Provides a large, potentially sparse address space, referenced by machine address. Portions of this space may be shared through inheritance or external memory management. • Contains some number of threads. Note that a task has no life of its own; only threads execute instructions. When it is said “a task Y does X” what is really meant is that “a thread contained within task Y does X”. A task is a fairly expensive entity. It exists to be a collection of resources. All of the threads in a task share everything. Two tasks share nothing without explicit action (although the action is often simple) and some resources cannot be shared between two tasks at all (such as port receive rights). A thread is a fairly light-weight entity. It is fairly cheap to create and has low overhead to operate. This is true because a thread has little state (mostly its register state); its owning task bears the burden of resource management. On a multiprocessor it is possible for multiple threads in a task to execute in parallel. Even when parallelism is not the goal, multiple threads have an advantage in that each thread can use a synchronous programming style, instead of attempting asynchronous programming with a single thread attempting to provide multiple services. Mach 3 Kernel Principles 3 Introduction Memory Management The Mach kernel provides the mechanisms to support large, potentially sparse virtual address spaces. Each task has an associated address map (maintained by the kernel) which controls the translation of virtual address in the task’s address space into physical addresses. As is true in virtual memory systems, the contents of the entire address space of any given task is most likely not completely resident in physical memory at any given time, and mechanisms must exist to use physical memory as a cache for the virtual address spaces of tasks. Unlike traditional virtual memory designs, the Mach kernel does not implement all of this caching itself; it endeavors to allow user mode tasks the ability to participate in these mechanisms. Unlike all other resources in the Mach system, virtual memory is not referenced via ports. Memory can be referenced only by using virtual addresses as indices into a particu- lar task’s address space. The memory (and the associated address map) that defines a task’s address space can be partially shared with other tasks. A task can allocate new ranges of memory within its address space, de-allocate them, and change protections on them. It can also specify inheritance properties for the ranges. A new task is created by specifying an existing task as a base from which to construct the address space for the new task. The inheritance attribute of each range of the memory of the existing task determines whether the new task has that range defined and whether that range is virtually copied or shared with the existing task. Within Mach, most virtual copy operations for memory are actually achieved through copy-on-write optimizations. A copy-on-write optimization is accomplished by not di- rectly copying the range, but by protected sharing. The two tasks both share the memory to be copied, but with read-only access. When either task attempts to modify a portion of the range, that portion is copied at that time. This lazy evaluation of memory copies is an important performance optimization performed by the Mach kernel, and important to the communication / memory philosophy of Mach.

Load more