XNU

From Wikipedia, the free encyclopedia

XNU kernel

Developer:	Apple Inc.
OS:	Darwin & Mac OS X
Use:	Kernel
License:	Apple Public Source License 2.0
Website:	http://kernel.macosforge.org/

Free software Portal

XNU is the name of the kernel that Apple acquired and developed for use in the Mac OS X operating system and released as open source as part of the Darwin operating system. XNU is an acronym for X is Not Unix^[1]—although this may become an inaccurate statement if Single UNIX Specification certification is received.^[2]

Originally developed by NeXT for the NEXTSTEP operating system, XNU was a hybrid kernel combining version 2.5 of the Mach kernel developed at Carnegie Mellon University with components from 4.3BSD and an object-oriented API for writing drivers called Driver Kit.

After the acquisition of NeXT by Apple, the Mach component was upgraded to 3.0, the BSD components were upgraded with code from the FreeBSD project and the Driver Kit was replaced with a C++ API for writing drivers called I/O Kit.

1 Kernel design
2 Protecting shared resources
3 References
4 External links

[edit] Kernel design

Like some other modern kernels, XNU is a hybrid, containing features of both monolithic and microkernels, attempting to make the best use of both technologies, such as the message passing capability of microkernels enabling greater modularity and larger portions of the OS to benefit from protected memory, as well as retaining the speed of monolithic kernels for certain critical tasks.

Mach was originally conceived as a simple microkernel. As such, it is able to run the core of an operating system as separated processes, which allows a great flexibility (one could run several operating systems in parallel above the Mach core), but this often reduced performance because of time consuming kernel/user mode context switches and overhead stemming from mapping or copying messages between the address spaces of the microkernel and that of the service daemons. With Mac OS X, the designers have attempted to streamline certain tasks and thus BSD functionalities were built into the core with Mach. The result is a combination of Mach and a classical BSD kernel, with some advantages and disadvantages of both.

Currently, XNU runs on x86 (Intel and AMD) based computers, as well as PowerPC based machines, both single processor and SMP models.

[edit] Mach

The core of the XNU kernel, Mach, provides kernel threads, processes, pre-emptive multitasking, message-passing (used in inter-process communication), protected memory, virtual memory management, very soft real-time support, kernel debugging support, and console I/O. The Mach component also allows the OS to host binaries for multiple distinct CPU architectures within a single file (such as x86 and PowerPC) due to its use of the Mach-O binary format.

[edit] BSD

The BSD portion of the kernel provides the POSIX API (BSD system calls), the Unix process model atop Mach tasks, basic security policies, user and group ids, permissions, the network stack, the virtual file system code (including a filesystem independent journalling layer), cryptographic framework, System V IPC, and some of the locking primitives. The BSD code present in XNU came from the FreeBSD kernel, although much of it has been significantly modified, and significant on-going code sharing occurs between Apple and the FreeBSD Project.

[edit] I/O Kit

I/O Kit is the device driver framework, written in a subset of C++. Due to its object-oriented design, device drivers can be written more quickly while using less code; features common to any class of driver are provided within the framework itself. The I/O Kit is multi-threaded, SMP safe, and allows for hot pluggable devices and automatic, dynamic device configuration.

Many drivers can be written to run from user-space, which further enhances the stability of the system; if a user-space driver crashes, it will not crash the kernel.

[edit] Protecting shared resources

In order to run safely on multiprocessor machines, access to shared resources (files, data structures etc.) must be serialized so that threads or processes do not attempt to modify the same resource at the same time. Atomic operations, spinlocks, critical sections, mutexes, and serializing tokens are all possible methods that can be used to prevent concurrent access. Like both Linux and FreeBSD 5, XNU, as of Mac OS X 10.4 and Darwin 8.0, employs a fine-grained mutex model to achieve higher performance on multiprocessor systems.