• Linux Kernel Formal Specification

So it made sense for Steve Jobs to use the most robust, secure and stable OS in existence as (part of) the kernel for the Mac OS X. The Mach micro-kernel is the other portion of the Mac OS X. NextStep is an off-shoot of BSD, and is one of Steve Jobs’ many “babies”, as is Mac OS X.

Advertisement Along with The sheer number of different ways in which Linux can be run is astounding, as there are plenty of choices to go around. While there are plenty of distributions which rely on either the.deb., compiling your own Linux kernel is one of those things that’s considered very geeky and technical. We’ve already Linux systems are so ridiculously flexible and configurable, it's downright crazy.

A huge part of why Linux is so flexible is because of its modular structure. Every single system component and program is split up. Why you might want to do this. Before we walk you through the steps, here’s a brief overview on some important concepts. What Is a Kernel? In short, it’s a vital part of your operating system, if not the most important. An operating system is responsible for letting your programs function, by allowing them access to your hardware.

However, it’s the There is only one de facto thing that Linux distributions have in common: the Linux kernel. But while it's often talked about, a lot of people don't really know exactly what it does.

Which actually carries all these jobs out. The Linux kernel is special in that it can be tailor made to fit the hardware you own.

Contrast this with the Windows NT kernel, which will be generally the same across every computer. To do this, the kernel must go through a process called compiling. What Is Compiling?

Generally, programs are written in a human readable format. This makes it easier for people to create software. For example, the Linux kernel is written mainly in a programming language called C. However, computers can’t understand this. They only recognize a complicated language called machine code.

To do so, the lines of text need to be using a special piece of software called a compiler. Different compilers are used to convert different programming languages. For example, GCC is a compiler which translates C code into machine code (among others).

But that’s not all they do — compilers can also optimize the translated code for specific machines. Along with this, they can also remove unwanted features from programs whilst doing so. Usually, this process is already done for lots of software. Instead, people download the converted binary instructions, which work out of the box.

For example, the Using the 'wrong' browser can lead to a lot of unnecessary headaches, wasted productivity, and even lost data. So which browser is the best for your Linux computer?

Let's find out. You’re running right now is already compiled. This is because compiling something can be a little bit complicated and time consuming. Think of it like translating a large book into a foreign language. In short, compiling the kernel means converting its code into something that will actually run on your computer. Obtaining Kernel Sources You can’t make a fire without fuel. Likewise, you can’t compile programs if you don’t have the code for it in the first place.

The method is generally the same for most Linux operating systems with a few exceptions. Many of them supply their own custom kernel sources. You should try and use that if you can.

For example, if you’re using a Debian-based operating system such as Ubuntu, you should install the sources using these commands: sudo apt-get update sudo apt-get install linux-source You can also install different versions of this package (e.g. Linux-source-4.8.0) if you like. You’ll find the installed files in the /usr/src/ directory, so navigate there, and view the contents. Cd /usr/src/ ls You’ll see a file that ends with.tar.bz2.

This is the source you’ll be using. Extract it with this command: sudo tar xjvf linux-source-4.4.0.tar.bz2 Make sure you replace the file with the correct name, of course. The file will be quite big, so the process will take a little while! Alternative Method If you like, you may obtain your sources from the. I recommend this only if your Linux operating system doesn’t provide them. Select the version you want and download away.

If you go through this route, you should download it to an empty folder. This way, if you want to compile more kernels in the future, you’ll have a nice folder to keep them organized in. Prerequisites Before you proceed, you must install some programs that will let you customize and compile it. On Debian-based systems, you need the build-essential package, among others: sudo apt-get install build-essential gcc libncurses5-dev libssl-dev The libncurses5-dev package will make it easier to configure the kernel, so make sure to install it. Dodocool usb hub thunderbolt gigabit ethernet lan network cable. Other Linux operating systems will have a similar program, but this may be under a different name.

For example, if you’re using Fedora isn't as well known as Ubuntu, and has a reputation for being hard to use. But if this is true, why do so many people continue using Fedora?, it’s called ncurses. If it’s not installed already, you’ll also need the GNU Compiler Collection (GCC). This is the tool responsible for translating the raw source code into something understandable to computers. That is to say, compiling. Having installed these programs, open up your terminal so that you’re inside the extracted Linux source folder.

For example, if you used the linux-source method, you’d do this: cd /usr/src/linux-source-4.4.0 Kernel Configuration File Before compiling the kernel, you need to tell GCC how you want it done. You do this using a command line tool called make. Type in this command: sudo make localmodconfig This creates a file called.config, which tells GCC what to compile from the kernel sources. The make localmodconfig command detects currently running kernel components, and marks them for compilation. If the kernel is inside a folder you own, you won’t need sudo for it to work. You may come across some messages like the one below. Just press the Enter key to skip them — they’re usually just new kernel features.

However, localmodconfig is not perfect! If you’re not currently using some parts of your computer, it may not detect all the things it supports. As such, you need to enable them manually. Alternatively, you can skip this step entirely and use the next command instead. This will compile the new kernel with the same options as the one you’re currently using.

If you’d prefer that, but used the localmodconifg command before, do this: sudo make clean This will give you a clean build. You should also use this command if you’ve compiled a kernel with these sources before.

Further Configuration Inside the kernel source folder, there’s a file called.config. This is what GCC will use to choose what to compile. Instead of editing it manually (not recommended), you’ll instead use a few terminal tools. This will make selecting compile options much easier. Having done this, fine tune it further: sudo make nconfig You’ll see a colorful menu pop up. This is the kernel configuration menu.

To navigate around, use the arrow keys. You can press the right arrow key to expand entries with a — sign next to them. Navigate out of these sub-menus by pressing the left arrow key. You can toggle menu entries that have the or sign next to them by pressing the space bar. This will cycle through the different menu options.

If you see a. or M inside, that specific kernel component will be compiled. The only difference between them is that the M option will be loaded when it’s needed. This can be useful if you’re compiling a driver for example, that won’t be used often. If you want to know more about what a specific switch does, press F2 over it. You’ll see a helpful description of what you’re compiling.

Once you’re all done, press the F9 button to save and exit. Compiling & Installing the Kernel Now that you’ve created a custom make file, you’ll need to the kernel. Type in this command: sudo make -j$(nproc -all) You will not need sudo if you downloaded the kernel sources off the web. The second part of the command helps speed up the kernel compile time, by taking advantage of all your Every computer has a processor, whether it's a small efficiency pro or a large performance powerhouse, or else it wouldn't be able to function. Of course, the processor, also called the CPU or Central Processing. You may get rid of this, or change the number to something else (e.g.j2), if you want to use your computer for other tasks without too many hiccups. However, this will also make the compiling slower!

This process can and will take a very long time. The less you chose to compile, the shorter it will be. Even so, you’ll probably need to be patient. Afterwards, type this command in to finish compiling the rest of the kernel: sudo make modulesinstall To actually use this kernel, you’ll need to enter this command: sudo make install This will automatically copy the kernel to your /boot folder and generate the appropriate files to make it work. Switching Kernels Using GRUB If you reboot after installing your new kernel, your system might not work! This is usually due to an improperly compiled kernel (that is, not supporting your computer well enough). Case in point, my own laptop.

Just in case this happens, I recommend so that it can switch back to older kernels. To do this, use this command: sudo nano /etc/default/grub Place a # sign in front of the GRUBHIDDENTIMEOUT and GRUBHIDDENTIMEOUTQUIET lines. Afterwards, save these changes by running this command: sudo grub-mkconfig -o /boot/grub/grub.cfg Now if you reboot your computer, you’ll be able to switch to an older kernel if your new one doesn’t work.

Simply go to the Advanced options menu item and select the kernel you want to boot. If everything works out fine, congratulations! You’ll be using the kernel you compiled by yourself. Are you interested in compiling more kernels?

Other programs? Do you find it worthwhile? Image Credits: chombosan/Shutterstock Explore more about:.

XNU kernel, OS family, Working state Current Source model Initial release December 1996; 22 years ago ( 1996-12) English, others Platforms, type 2.0 Official website XNU is the computer developed at since December 1996 for use in the operating system and released as as part of the operating system. It is also used as the kernel for the, and operating systems. XNU is an abbreviation of X is Not or XNU is Not. Originally developed by for the operating system, XNU was a combining version 2.5 of the developed at with components from and an API for writing drivers called Driver Kit. After Apple acquired NeXT, the Mach component was upgraded to 7.3 from OSF, the BSD components were upgraded with code from the project, and the Driver Kit was replaced with a API for writing drivers called.

Contents. Kernel design XNU is a, containing features of both and, attempting to make the best use of both technologies, such as the ability of microkernels enabling greater modularity and larger portions of the OS to benefit from, and retaining the speed of monolithic kernels for some critical tasks.

As of 2007, XNU runs on, and processors, both one processor and (SMP) models. Support is removed as of version 10 (i.e., ). Mach The basis of the XNU kernel is a heavily modified (hybrid) 7.3 kernel. As such, it is able to run the core of an operating system as separated processes, which allows a great flexibility (it could run several operating systems in parallel above the Mach core), but this often reduces performance because of time consuming kernel/user mode context switches and overhead stemming from mapping or copying messages between the address spaces of the kernel and that of the service daemons.

With Mac OS X, the designers have attempted to streamline some tasks and thus functionality was built into the core with Mach. The result is a heavily modified (hybrid) OSFMK 7.3 kernel, Apple licensed OSFMK 7.3, which is a microkernel, from the OSF. (OSFMK 7.3 includes applicable code from the University of Utah Mach 4 kernel and applicable code from the many Mach 3.0 variants that sprouted off from the original Carnegie Mellon University Mach 3.0 microkernel.) BSD The (BSD) part of the kernel provides the (API, BSD system calls), the process model atop Mach tasks, basic security policies, user and group ids, permissions, the, the code (including a filesystem independent layer), several local file systems such as /, the (NFS) client and server, cryptographic framework, (IPC), audit subsystem, and some of the locking primitives. The BSD code present in XNU came from the kernel. Although much of it has been significantly modified, code sharing still occurs between Apple and the FreeBSD Project. This section needs to be updated.

In particular: Does not describe any changes since 10.6. Please update this article to reflect recent events or newly available information. (December 2017) XNU in, v10.6, ( version 10) comes in two varieties, a version called K32 and a version called K64. K32 can run 64-bit applications in.

What was new in Mac OS X 10.6 was the ability to run XNU in 64-bit. K32 was the default kernel for 10.6 Server when used on all machines except and models from 2008 onwards and can run 64-bit applications.

K64 has several benefits compared to K32:. Can manage more than 32 GB RAM, as the memory map would consume a disproportionately large area of the 32-bit kernel space. Cache buffer sizes can be larger than what the 32-bit kernel space allows, potentially increasing I/O performance.

Performance is increased when using high-performance networking devices or multiple (GPUs), as the kernel can map all of the devices in 64-bit space even if several have very large (DMA) buffers. Booting while holding down 6 and 4 forces the machine to boot K64 on machines supporting 64-bit kernels. K64 will run 32-bit applications but it will not run 32-bit (KEXTs) so these must be ported to K64 to be able to load. XNU in, v10.7, and later only provides a 64-bit kernel. I/O Kit is the framework, written in a subset of based on. Using its design, features common to any class of driver are provided within the framework, helping device drivers be written in less time and code. 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, which further enhances the stability of the system. If a user-space driver crashes, it will not crash the kernel.

Linux Kernel Formal Specification

However, if a kernel-space driver crashes it will crash the kernel. Examples of kernel-space drivers include disk adapter and network adapter drivers, graphics drivers, drivers for Universal Serial Bus and, and drivers for software such as,. Protecting shared resources 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., ('mutexes'), and are all possible methods that can be used to prevent concurrent access. Like recent versions of and, XNU, as of Mac OS X 10.4 and Darwin 8.0, employs a fine-grained mutex model to achieve higher performance on systems. See also. Apple Computer. Retrieved June 7, 2017.

^ Jim Magee. 14 minutes in. (July 1, 2007) Retrieved January 6, 2008. Douglas M.

(August 2, 2008). Freebsd-advocacy (Mailing list). Retrieved October 24, 2013.

Retrieved October 24, 2013. John Siracusa (August 31, 2009). Finally, this is worth repeating: please keep in mind that you do not need to run the 64-bit kernel in order to run 64-bit applications or install more than 4GB of RAM in your Mac. Applications run just fine in 64-bit mode on top of the 32-bit kernel, and even in earlier versions of Mac OS X it's been possible to install and take advantage of much more than 4GB of RAM. External links.

– an overview of the components of XNU, written by Amit Singh in December 2003. – 'This talk intends to clear up the confusion by presenting details of the Mac OS X kernel'.