The Linux kernel is a monolithic Unix-like computer operating system kernel.

The
Linux family of operating systems is based on this kernel and deployed on both
traditional computer systems such as personal computers and servers, usually in the
form of Linux distributions,[9] and on various embedded devices such as routers,
wireless access points, PBXes, set-top boxes, FTA receivers, smart TVs, PVRs, and
NAS appliances. The Android operating system for tablet computers, smartphones, and
smartwatches uses services provided by the Linux kernel to enable its
functionality. While the adoption on desktop computers is low, Linux-based
operating systems dominate nearly every other segment of computing, from mobile
devices to mainframes. As of June 2017, 498 of the world's 500 most powerful
supercomputers run Linux (The remaining two run AIX, a proprietary Unix operating
system on IBM POWER7 hardware).[10]

The Linux kernel was conceived and created in 1991 by Linus Torvalds[11] for his
personal computer and with no cross-platform intentions, but has since expanded to
support a huge array of computer architectures, many more than other operating
systems or kernels. Linux rapidly attracted developers and users who adopted it as
the kernel for other free software projects, notably the GNU Operating System.[12]
The Linux kernel has received contributions from nearly 12,000 programmers from
more than 1,200 companies, including some of the largest software and hardware
vendors.[13][14]

The Linux kernel API, the application programming interface (API) through which
user programs interact with the kernel, is meant to be very stable and to not break
userspace programs (some programs, such as those with GUIs, rely on other APIs as
well). As part of the kernel's functionality, device drivers control the hardware;
"mainlined" device drivers are also meant to be very stable. However, the interface
between the kernel and loadable kernel modules (LKMs), unlike in many other kernels
and operating systems, is not meant to be very stable by design.[15]

The Linux kernel, developed by contributors worldwide, is a prominent example of

free and open source software.[16] Day-to-day development discussions take place on
the Linux kernel mailing list (LKML). The Linux kernel is released under the GNU
General Public License version 2 (GPLv2),[6][17] with some firmware images released
under various non-free licenses.[8]

Contents [hide]
1 History 1.1 TanenbaumTorvalds debate
1.2 Popularity

2 Legal aspects 2.1 Licensing terms 2.1.1 GPL version 3

2.2 Loadable kernel modules

2.3 Firmware binary blobs
2.4 Trademark
2.5 SCO litigation

3 Architecture 3.1 Programming language

3.2 Compiler compatibility
3.3 Interfaces 3.3.1 Kernel-to-userspace API
3.3.2 Kernel-to-userspace ABI
3.3.3 In-kernel API
3.3.4 In-kernel ABI

3.4 Technical features 3.4.1 Preemption

3.4.2 Portability
3.4.3 Kernel panic and oopses
3.4.4 Live patching

3.5 Security
3.6 Feature history

4 Development 4.1 Developer community

4.2 Codebase
4.3 Estimated cost to redevelop
4.4 Development model 4.4.1 Relation with Linux distributions

4.5 Maintenance 4.5.1 Releases before 2.6.0

4.5.2 2.6.x.y releases
4.5.3 3.x.y releases
4.5.4 4.x.y releases

4.6 Revision control

4.7 Version numbering
4.8 Timeline
4.9 Variants

5 See also
6 Notes
7 References
8 Further reading
9 External links

History[edit]

See also: History of Linux

Linus Torvalds
In April 1991, Linus Torvalds, at the time a 21-year-old computer science student
at the University of Helsinki, Finland, started working on some simple ideas for an
operating system. He started with a task switcher in Intel 80386 assembly language
and a terminal driver. On 25 August 1991, Torvalds posted the following to
comp.os.minix, a newsgroup on Usenet:[18]

I'm doing a (free) operating system (just a hobby, won't be big and professional
like gnu) for 386(486) AT clones. This has been brewing since April, and is
starting to get ready. I'd like any feedback on things people like/dislike in
minix, as my OS resembles it somewhat (same physical layout of the file-system (due
to practical reasons) among other things).

I've currently ported bash(1.08) and gcc(1.40), and things seem to work. This
implies that I'll get something practical within a few months [...] Yes - it's free
of any minix code, and it has a multi-threaded fs. It is NOT portable (uses 386
task switching etc), and it probably never will support anything other than AT-
harddisks, as that's all I have :-(.

[...] It's mostly in C, but most people wouldn't call what I write C. It uses every
conceivable feature of the 386 I could find, as it was also a project to teach me
about the 386. As already mentioned, it uses a MMU, for both paging (not to disk
yet) and segmentation. It's the segmentation that makes it REALLY 386 dependent
(every task has a 64Mb segment for code & data - max 64 tasks in 4Gb. Anybody who
needs more than 64Mb/task - tough cookies). [...] Some of my "C"-files
(specifically mm.c) are almost as much assembler as C. [...] Unlike minix, I also
happen to LIKE interrupts, so interrupts are handled without trying to hide the
reason behind them.

After that, many people contributed code to the project. Early on, the MINIX
community contributed code and ideas to the Linux kernel. At the time, the GNU
Project had created many of the components required for a free operating system,
but its own kernel, GNU Hurd, was incomplete and unavailable. The BSD operating
system had not yet freed itself from legal encumbrances. Despite the limited
functionality of the early versions, Linux rapidly gained developers and users.

By September 1991, version 0.01 of the Linux kernel was released on the FTP server
(ftp.funet.fi) of the Finnish University and Research Network (FUNET). It had
10,239 lines of code. In October 1991, version 0.02 of the Linux kernel was
released.[19]

In December 1991, Linux kernel 0.11 was released. This version was the first to be
self-hosted as Linux kernel 0.11 could be compiled by a computer running the same
kernel version. When Torvalds released version 0.12 in February 1992, he adopted
the GNU General Public License (GPL) over his previous self-drafted license, which
had not permitted commercial redistribution.[20]

A newsgroup known as alt.os.linux was started, and on 19 January 1992, the first
post to alt.os.linux was made.[21] On 31 March 1992, alt.os.linux became
comp.os.linux.[22]

The X Window System was soon ported to Linux. In March 1992, Linux version 0.95 was
the first to be capable of running X. This large version number jump (from 0.1x to
0.9x) was due to a feeling that a version 1.0 with no major missing pieces was
imminent. However, this proved to be somewhat overoptimistic, and from 1993 to
early 1994, 15 development versions of version 0.99 appeared.

On 14 March 1994, Linux kernel 1.0.0 was released, with 176,250 lines of code. In
March 1995, Linux kernel 1.2.0 was released, with 310,950 lines of code.

Version 2 of the Linux kernel, released on 9 June 1996, was followed by additional
major versions under the version 2 header:
25 January 1999 release of Linux kernel 2.2.0 (1,800,847 lines of code)
18 December 1999 IBM mainframe patches for 2.2.13 were published, allowing Linux
kernel to be used on enterprise-class machines
4 January 2001 release of Linux kernel 2.4.0 (3,377,902 lines of code)
17 December 2003 release of Linux kernel 2.6.0 (5,929,913 lines of code)

Starting in 2004, the release process changed and new kernels started coming out on
a regular schedule every 23 months, numbered 2.6.0, 2.6.1, up through 2.6.39.

On 21 July 2011, Torvalds announced the release of Linux kernel 3.0: "Gone are the
2.6.<bignum> days".[23] The version bump is not about major technological changes
when compared to Linux 2.6.39;[24] it marks the kernel's 20th anniversary.[25] The
time-based release process remained the same.

Version 3.10 of the Linux kernel, released in June 2013, contains 15,803,499 lines
of code,[26] while the version 4.1, released in June 2015, has grown to over 19.5
million lines of code contributed by almost 14,000 programmers.[27]

TanenbaumTorvalds debate[edit]
Main article: TanenbaumTorvalds debate

The fact that Linux is a monolithic kernel rather than a microkernel was the topic
of a debate between Andrew S. Tanenbaum, the creator of MINIX, and Linus Torvalds.
[28] The debate, started in 1992 on the Usenet discussion group comp.os.minix, was
about Linux and kernel architecture in general.[29] Tanenbaum argued that
microkernels are superior to monolithic kernels and that therefore Linux is
obsolete. Unlike traditional monolithic kernels, device drivers in Linux are easily
configured as loadable kernel modules and are loaded or unloaded while running the
system. This subject was revisited on 9 May 2006,[30] and on 12 May 2006 Tanenbaum
wrote a position statement.[31]

Popularity[edit]

The huge rise in popularity of the Android operating system, which includes the
Linux kernel, has made the kernel the most popular choice for mobile devices,
rivaling the installed base of all other operating systems.[32][33][34] Including
previous years, three billion Android smartphones were estimated to have been sold
by the end of 2014.

Many consumer routers also use the Linux kernel,[35] as well as a wide variety of
other embedded devices, such as smart TVs, set-top boxes, and webcams. Many desktop
Linux distributions including the Linux kernel exist, but the usage share of Linux
distributions is low in comparison to other operating systems.

Legal aspects[edit]

Licensing terms[edit]

Initially, Torvalds released Linux under a license which forbade any commercial
use.[36] This was changed in version 0.12 by a switch to the GNU General Public
License (GPL).[20] This license allows distribution and sale of possibly modified
and unmodified versions of Linux but requires that all those copies be released
under the same license and be accompanied by the complete corresponding source
code.

Torvalds has described licensing Linux under the GPL as the "best thing I ever
did".[36]

GPL version 3[edit]

The Linux kernel is licensed explicitly only under version 2 of the GPL,[6] without
offering the licensee the option to choose "any later version", which is a common
GPL extension. There was considerable debate about how easily the license could be
changed to use later GPL versions (including version 3), and whether this change is
even desirable.[37] Torvalds himself specifically indicated upon the release of
version 2.4.0 that his own code is released only under version 2.[38] However, the
terms of the GPL state that if no version is specified, then any version may be
used,[verification needed] and Alan Cox pointed out that very few other Linux
contributors had specified a particular version of the GPL.[39]

In September 2006, a survey of 29 key kernel programmers indicated that 28

preferred GPLv2 to the then-current GPLv3 draft. Torvalds commented, "I think a
number of outsiders... believed that I personally was just the odd man out, because
I've been so publicly not a huge fan of the GPLv3."[40] This group of high-profile
kernel developers, including Linus Torvalds, Greg Kroah-Hartman and Andrew Morton,
commented on mass media about their objections to the GPLv3.[41] They referred to
clauses regarding DRM/tivoization, patents, "additional restrictions" and warned a
Balkanisation of the "Open Source Universe" by the GPLv3.[41][42] Linus Torvalds,
who decided not to adopt the GPLv3 for the Linux kernel, reiterated his criticism
even years later.[43]

Loadable kernel modules[edit]

It is debated whether loadable kernel modules (LKMs) are to be considered

derivative works under copyright law, and thereby fall under the terms of the GPL.

Torvalds has stated his belief that LKMs using only a limited, "public" subset of
the kernel interfaces can sometimes be non-derived works, thus allowing some
binary-only drivers and other LKMs that are not licensed under the GPL.[citation
needed] A very good example for this is the usage of dma_buf by the proprietary
Nvidia graphics drivers. dma_buf is a recent kernel feature (like the rest of the
kernel, it is licensed under the GPL) that allows multiple GPUs to quickly copy
data into each other's framebuffers.[44] One possible use case would be Nvidia
Optimus that pairs a fast GPU with an Intel integrated GPU, where the Nvidia GPU
writes into the Intel framebuffer when it is active. But, Nvidia cannot use this
infrastructure because it uses a technical means to enforce the rule that it can
only be used by LKMs that are also GPL. Alan Cox replied on LKML, rejecting a
request from one of their engineers to remove this technical enforcement from the
API.[45] Not all Linux kernel contributors agree with this interpretation, however,
and even Torvalds agrees that many LKMs are clearly derived works, and indeed he
writes that "kernel modules ARE derivative 'by default'".[46]

On the other hand, Torvalds has also said that "one gray area in particular is
something like a driver that was originally written for another operating system
(i.e. clearly not a derived work of Linux in origin). [...] THAT is a gray area,
and _that_ is the area where I personally believe that some modules may be
considered to not be derived works simply because they weren't designed for Linux
and don't depend on any special Linux behaviour."[47] Proprietary graphics drivers,
in particular, are heavily discussed. Ultimately, it is likely that such questions
can only be resolved by a court.

Firmware binary blobs[edit]

One point of licensing controversy is the use of firmware "binary blobs" in Linux
kernel to support several hardware devices. These files are under a variety of
licenses, out of which many are restrictive and their exact underlying source code
is usually unknown.[8]

In 2002, Richard Stallman stated why, in his point of view, such blobs make the
Linux kernel partially non-free software, and that distributing Linux kernel
"violates the GPL", which requires "complete corresponding source code" to be
available.[7] In 2008, Free Software Foundation Latin America started Linux-libre
as a project that creates a completely free variant of the Linux kernel without
proprietary objects; it is used by certain completely free Linux distributions,
such as those endorsed by the Free Software Foundation, while it can also be used
on most distributions.[48]

On 15 December 2010, the Debian Project announced that the next Debian stable
version "6.0 Squeeze" would come with a kernel "stripped of all non-free firmware
bits".[49] This policy was continued to be applied in later stable Debian releases.

Trademark[edit]

See also: Linux: Copyright, trademark, and naming

Linux is a registered trademark of Linus Torvalds in the United States and some
other countries. This is the result of an incident in which William Della Croce,
Jr., who was not involved in the Linux project, trademarked the name and
subsequently demanded royalties for its use.[50] Several Linux backers retained
legal counsel and filed suit against Della Croce. The issue was settled in August
1997 when the trademark was assigned to Linus Torvalds.[51][52]

SCO litigation[edit]

For more details on this topic, see SCO/Linux controversies.

In March 2003, the SCO Group (SCO) filed a lawsuit against IBM claiming that IBM
had violated copyrights that SCO claimed to hold over the Unix source code, by
contributing portions of that code to Linux. Additionally, SCO sent letters to a
number of companies warning that their use of Linux without a license from SCO may
be a violation of copyright law, and claimed in the press that they would be suing
individual Linux users. IBM then promised to defend its Linux customers on their
behalf. This controversy has generated lawsuits by SCO against Novell,
DaimlerChrysler (partially dismissed in July 2004), and AutoZone, and retaliatory
lawsuits by Red Hat and others against SCO.

In early 2007, SCO filed the specific details of the purported copyright
infringement. Despite previous claims that SCO was the rightful owner of 1 million
lines of code, they specified 326 lines of code, most of which were
uncopyrightable.[53] In August 2007, the court in the Novell case ruled that SCO
did not actually own the Unix copyrights to begin with,[54] though the Tenth
Circuit Court of Appeals ruled in August 2009 that the question of who owned the
copyright properly remained for a jury to answer.[55] The jury case was decided on
30 March 2010 in Novell's favour.[56]

Architecture[edit]

See also: vmlinux

Map of the Linux kernel

Linux kernel supports various hardware architectures, providing a common platform

for software (including possibly proprietary).
The Linux kernel is a monolithic kernel, supporting true preemptive multitasking
(both in user mode and, since the 2.6 series, in kernel mode[57][58]), virtual
memory, shared libraries, demand loading, shared copy-on-write executables (via
KSM), memory management, the Internet protocol suite, and threading.

Device drivers and kernel extensions run in kernel space (ring 0 in many CPU
architectures), with full access to the hardware, although some exceptions run in
user space, for example filesystems based on FUSE/CUSE, and parts of UIO.[59][60]
The graphics system most people use with Linux does not run within the kernel.
Unlike standard monolithic kernels, device drivers are easily configured as
modules, and loaded or unloaded while the system is running. Also, unlike standard
monolithic kernels, device drivers can be pre-empted under certain conditions; this
feature was added to handle hardware interrupts correctly, and to better support
symmetric multiprocessing.[58] By choice, the Linux kernel has no binary kernel
interface.[61]
The hardware is also incorporated into the file hierarchy. Device drivers interface
to user applications via an entry in the /dev or /sys directories.[62] Process
information as well is mapped to the file system through the /proc directory.[62]

Various layers within Linux, also showing separation between the userland and
kernel space

User mode
User applications For example, bash, LibreOffice, GIMP, Blender, 0 A.D., Mozilla
Firefox, etc.
Low-level system components: System daemons:
systemd, runit, logind, networkd, PulseAudio, ... Windowing system:
X11, Wayland, Mir, SurfaceFlinger (Android) Other libraries:
GTK+, Qt, EFL, SDL, SFML, FLTK, GNUstep, etc. Graphics:
Mesa, AMD Catalyst, ...
C standard library open(), exec(), sbrk(), socket(), fopen(), calloc(), ... (up to
2000 subroutines)
glibc aims to be POSIX/SUS-compatible, uClibc targets embedded systems, bionic
written for Android, etc.

Kernel mode
Linux kernel stat, splice, dup, read, open, ioctl, write, mmap, close, exit, etc.
(about 380 system calls)
The Linux kernel System Call Interface (SCI, aims to be POSIX/SUS-compatible)
Process scheduling
subsystem IPC
subsystem Memory management
subsystem Virtual files
subsystem Network
subsystem
Other components: ALSA, DRI, evdev, LVM, device mapper, Linux Network Scheduler,
Netfilter
Linux Security Modules: SELinux, TOMOYO, AppArmor, Smack

Hardware (CPU, main memory, data storage devices, etc.)

Programming language[edit]

The Linux kernel is written in the version of the C programming language supported
by GCC (which has introduced a number of extensions and changes to standard C),
together with a number of short sections of code written in the assembly language
(in GCC's "AT&T-style" syntax) of the target architecture. Because of the
extensions to C it supports, GCC was for a long time the only compiler capable of
correctly building the Linux kernel.

Compiler compatibility[edit]

GCC is the default compiler for the Linux kernel source. In 2004, Intel claimed to
have modified the kernel so that its C compiler was also capable of compiling it.
[63] There was another such reported success in 2009, with a modified 2.6.22
version of the kernel.[64][65]

Since 2010, effort has been underway to build the Linux kernel with Clang, an
alternative compiler for the C language;[66] as of 12 April 2014, the official
kernel could almost be compiled by Clang.[67][68] The project dedicated to this
effort is named LLVMLinux after the LLVM compiler infrastructure upon which Clang
is built.[69] LLVMLinux does not aim to fork either the Linux kernel or the LLVM,
therefore it is a meta-project composed of patches that are eventually submitted to
the upstream projects. By enabling the Linux kernel to be compiled by Clang that,
among other advantages, is known for faster compilation compared with GCC, kernel
developers may benefit from a faster workflow due to shorter compilation times.[70]

Interfaces[edit]

Main articles: Linux kernel interfaces and Interfaces of the Linux kernel
(Category)

This section needs additional citations for verification. Please help improve this
article by adding citations to reliable sources. Unsourced material may be
challenged and removed. (January 2015) (Learn how and when to remove this template
message)

Four interfaces are distinguished: two internal to the kernel, and two between the
kernel and userspace.

At XDC2014, Alex Deucher from AMD announced the unified kernel-mode driver.[71]
The proprietary Linux graphic driver, libGL-fglrx-glx, will share the same DRM
infrastructure with Mesa 3D. As there is no stable in-kernel ABI, AMD had to
constantly adapt the former binary blob used by Catalyst.
Conformance to standards is a general policy for the Linux kernel's internals.
Another rule is that a kernel component is not accepted into the Linux kernel
mainline if there is only proprietary user-space software using that component.
[citation needed]

Kernel-to-userspace API[edit]

Main articles: POSIX and Single UNIX Specification

Source code portability ensures that a C program written by conforming to a

standard can be successfully compiled and run on any system that also conforms to
the same standard. The relevant standards, aiming to achieve source code
portability of programs, that the development of the Linux kernel, the GNU C
Library, and associated utilities tries to adhere to, are POSIX and the Single UNIX
Specification. Inspur K-UX is distribution by chinese Inspur based on Red Hat
Enterprise Linux and is a certified "UNIX" by The Open Group.[72]

The Linux kernel API of the Linux kernel, representing the kernel's system call
interface, is composed of the available system calls.

Kernel-to-userspace ABI[edit]

Main article: Linux Standard Base

Binary portability shall guarantee that any program once compiled for a given
hardware platform, can be run in its compiled form on any other hardware platform
that conforms to the standard. Binary portability is an essential requirement for
the commercial viability of independent software vendor (ISV) applications built
for the operating systems based on the Linux kernel. Binary compatibility is much
more demanding than source code portability; as of February 2014, the only standard
concerning itself with binary compatibility is the Linux Standard Base (LSB).

In-kernel API[edit]

There are a couple of kernel internal APIs utilized between the different
subsystems and subsystems of subsystems. Some of them have been kept stable over
several releases, others have not. There are no guarantees regarding the in-kernel
APIs. Maintainers and contributors are free to augment or change them at any time.
[73]

Examples of in-kernel APIs include software frameworks/APIs for the following

classes of device drivers:
Video4Linux for video capture hardware
Advanced Linux Sound Architecture (ALSA) for sound cards
New API for network interface controllers
Direct Rendering Manager for graphics accelerators
KMS driver for display controllers
mac80211 for wireless network interface controllers[74]
WEXT for wireless network interface controllers (obsolete).

In-kernel ABI[edit]

Some organizations have strongly supported defining and maintaining of a stable in-
kernel ABI over several releases.[citation needed] For example, it would benefit
hardware manufacturers which release proprietary kernel modules and distribute
binary-only software (e.g. device drivers).[citation needed] However, the Linux
kernel developers choose not to maintain a stable in-kernel ABI.[75] This allows
Linux kernel development to happen much more quickly.[citation needed]

Technical features[edit]

Preemption[edit]

See also: Kernel preemption

The position of I/O schedulers within various layers of the Linux kernel's storage
stack.[76]
The Linux kernel provides preemptive scheduling under certain conditions. Until
kernel version 2.4, only user processes were preemptive, i.e., in addition to time
quantum expiration, an execution of current process in user mode would be
interrupted if higher dynamic priority processes entered TASK_RUNNING state.[77]
Toward 2.6 series of the Linux kernel, an ability to interrupt a task executing
kernel code was added, although with that not all sections of the kernel code can
be preempted.[78]

The Linux kernel contains different scheduler classes.[79] By default the kernel
uses a scheduler mechanism called the Completely Fair Scheduler introduced in the
2.6.23 version of the kernel.[80] Internally this default-scheduler class is also
known as SCHED_OTHER, but the kernel also contains two POSIX-compliant[81] real-
time scheduling classes named SCHED_FIFO (realtime first-in-first-out) and SCHED_RR
(realtime round-robin), both of which take precedence over the default class.[79]

Through the use of the real-time Linux kernel patch PREEMPT_RT, support for full
preemption of critical sections, interrupt handlers, and "interrupt disable" code
sequences can be supported.[82] Partial mainline integration of the real-time Linux
kernel patch already brought some functionality to the kernel mainline.[83]
Preemption improves latency, increases responsiveness, and makes Linux more
suitable for desktop and real-time applications. Older versions of the kernel had a
so-called big kernel lock for synchronization across the entire kernel, which was
finally removed by Arnd Bergmann in 2011.[84]

Additional scheduling policy known as SCHED_DEADLINE, implementing the earliest

deadline first algorithm (EDF), was added in kernel version 3.14, released on 30
March 2014.[85][86]

Portability[edit]

See also: List of Linux supported architectures and Linux-powered device

An iPod booting iPodLinux

While not originally designed to be portable,[18][87] Linux is now one of the most
widely ported operating system kernels, running on a diverse range of systems from
the ARM architecture to IBM z/Architecture mainframe computers. The first port
beyond Linux's original 386 architecture was performed on the Motorola 68000
platform by Amiga users, who accomplished this by replacing major parts of the
kernel. The modifications to the kernel were so fundamental that Torvalds viewed
the Motorola version as a fork and a "Linux-like operating system"[87] rather than
as an actual port. It was, however, the impetus that Torvalds needed to lead a
major restructure of the kernel code to facilitate porting to competing computing
architectures. The first Linux endorsed port was to the DEC Alpha AXP 32 bit
platform which was demonstrated at DECUS in May, 1995m[88] supporting both 386 and
Alpha in a single source tree.[87] DEC was responsible for supplying the hardware
necessary to Torvalds to enable a port of Linux to 64 bits[89] that same year.

Linux runs as the main operating system on IBM's Blue Gene and other fastest
supercomputers, including the top Chinese one. As of June 2017, 99+% of the world's
500 fastest supercomputers run some variant of Linux,[10] that is all of them
except the 493rd and 494th fastest which run on Unix.[90] Linux has also been
ported to various handheld devices such as Apple's iPod and iPhone.[91] Some
operating systems developed for mobile phones use modified versions of the Linux
kernel, including Google Android, Firefox OS, HP webOS, Nokia Maemo and Jolla
Sailfish OS.[92][93][94]

Kernel panic and oopses[edit]

An example of Linux kernel panic

Main articles: Kernel panic and Linux kernel oops

In Linux, a "panic" is an unrecoverable system error detected by the kernel, as

opposed to similar errors detected by user space code. It is possible for kernel
code to indicate such a condition by calling the panic function located in the
header file sys/system.h. However, most panics are the result of unhandled
processor exceptions in kernel code, such as references to invalid memory
addresses. These are typically indicative of a bug somewhere in the call chain
leading to the panic. They can also indicate a failure of hardware, such as a
failed RAM cell or errors in arithmetic functions in the processor caused by a
processor bug, overheating/damaged processor, or a soft error.

A report of a non-fatal bug in the kernel is called an "oops"; such deviations from
correct behavior of the Linux kernel may allow continued operation with compromised
reliability.[95] These crash reports are automatically collected and can be sent
upstream by various software, such as kerneloops,[96] ABRT (Fedora)[97] and apport
(Ubuntu). KernelOops.org collects these reports and publishes statistics on their
website.[98]

The kernel panic message might not be printed visibly in some conditions, such as
when using a graphical desktop. To debug such conditions, other methods such as
attaching a serial port console can be used.

Live patching[edit]

Rebootless updates can even be applied to the kernel by using live patching
technologies such as Ksplice, kpatch and kGraft. Minimalistic foundations for live
kernel patching were merged into the Linux kernel mainline in kernel version 4.0,
which was released on 12 April 2015. Those foundations, known as livepatch and
based primarily on the kernel's ftrace functionality, form a common core capable of
supporting hot patching by both kGraft and kpatch, by providing an application
programming interface (API) for kernel modules that contain hot patches and an
application binary interface (ABI) for the userspace management utilities. However,
the common core included into Linux kernel 4.0 supports only the x86 architecture
and does not provide any mechanisms for ensuring function-level consistency while
the hot patches are applied. As of April 2015, there is ongoing work on porting
kpatch and kGraft to the common live patching core provided by the Linux kernel
mainline.[99][100][101]

Security[edit]

Computer security is a much-publicized topic in relation to the Linux kernel

because a large portion of the kernel bugs present potential security flaws. For
example, they may allow for privilege escalation or create denial-of-service attack
vectors. Over the years, numerous such flaws were found and fixed in the Linux
kernel.[102] New security features are frequently implemented to improve the Linux
kernel's security.[103][104]

Critics have accused kernel developers of covering up security flaws or at least

not announcing them; in 2008, Linus Torvalds responded to this with the following:
[105][106]

I personally consider security bugs to be just "normal bugs". I don't cover them
up, but I also don't have any reason what-so-ever to think it's a good idea to
track them and announce them as something special...one reason I refuse to bother
with the whole security circus is that I think it glorifiesand thus encouragesthe
wrong behavior. It makes "heroes" out of security people, as if the people who
don't just fix normal bugs aren't as important. In fact, all the boring normal bugs
are way more important, just because there's a lot more of them. I don't think some
spectacular security hole should be glorified or cared about as being any more
"special" than a random spectacular crash due to bad locking.

Linux distributions typically release security updates to fix vulnerabilities in

the Linux kernel. Many offer long-term support releases that receive security
updates for a certain Linux kernel version for an extended period of time.
Feature history[edit]

Version 1.0 of the Linux kernel was released on 14 March 1994.[107] This release of
the Linux kernel only supported single-processor i386-based computer systems.
Portability became a concern, and so version 1.2 (released 7 March 1995)[108]
gained support for computer systems using processors based on the Alpha, SPARC, and
MIPS architectures.

Version 2.0 was released on 9 June 1996.[109] There were 41 releases in the series.
The major feature of 2.0 was SMP support (that is, support for multiple processors
in a single system) and support for more types of processors.

Version 2.2, released on 20 January 1999,[110] removed the global spinlock and
provided improved SMP support, added support for the m68k and PowerPC
architectures, and added new file systems (including read-only support for
Microsoft's NTFS).[111]

Version 2.4.0, released on 4 January 2001,[112] contained support for ISA Plug and
Play, USB, and PC Cards.[113] It also included support for the PA-RISC processor
from Hewlett-Packard. Development for 2.4.x changed a bit in that more features
were made available throughout the duration of the series, including: support for
Bluetooth, Logical Volume Manager (LVM) version 1, RAID support, InterMezzo and
ext3 file systems.

Version 2.6.0 was released on 17 December 2003.[114] The development for 2.6.x
changed further towards including new features throughout the duration of the
series. Among the changes that have been made in the 2.6 series are: integration of
Clinux into the mainline kernel sources, PAE support, support for several new
lines of CPUs, integration of Advanced Linux Sound Architecture (ALSA) into the
mainline kernel sources, support for up to 232 users (up from 216), support for up
to 229 process IDs (64-bit only, 32-bit arches still limited to 215),[115]
substantially increased the number of device types and the number of devices of
each type, improved 64-bit support, support for file systems which support file
sizes of up to 16 terabytes, in-kernel preemption, support for the Native POSIX
Thread Library (NPTL), User-mode Linux integration into the mainline kernel
sources, SELinux integration into the mainline kernel sources, InfiniBand support,
and considerably more. Also notable are the addition of several file systems
throughout the 2.6.x releases: FUSE, JFS, XFS, ext4 and more. Details on the
history of the 2.6 kernel series can be found in the ChangeLog files on the 2.6
kernel series source code release area of kernel.org.[116]

Version 3.0 was released on 22 July 2011.[23] On 30 May 2011, Torvalds announced
that the big change was "NOTHING. Absolutely nothing." and asked "...let's make
sure we really make the next release not just an all new shiny number, but a good
kernel too."[117] After the expected 67 weeks of the development process, it would
be released near the 20th anniversary of Linux.

In December 2012, Torvalds decided to reduce kernel complexity by removing support

for i386 processors, making the 3.7 kernel series the last one still supporting the
original processor.[118][119] The same series unified support for the ARM
processor.[120]

Version 3.11, released on 2 September 2013,[121] adds many new features such as new
O_TMPFILE flag for open(2) to reduce temporary file vulnerabilities, experimental
AMD Radeon dynamic power management, low-latency network polling, and zswap
(compressed swap cache).[122]

There were no meaningful technical reasons for the numbering change from 2.6.39 to
3.0, or from 3.19 to 4.0. The major version number was increased just to avoid
large minor numbers.[23][123]