Linux 4.x Kernel Download
Linneo Pxlx
Day-to-day development discussions take place on the Linux kernel mailing list (LKML). Changes are tracked using the version control system git, which was originally authored by Torvalds as a free software replacement for BitKeeper.
After that, despite the limited functionality of the early versions, Linux rapidly gained developers and users. Many people contributed code to the project, including some developers from the MINIX community.[citation needed] At the time, the GNU Project had created many of the components required for its free UNIX replacement, the GNU operating system, but its own kernel, GNU Hurd, was incomplete. For this reason, it soon adopted the Linux kernel as well.[25] The Berkeley Software Distribution had not yet freed itself from legal encumbrances and was not competing in the space for a free OS kernel.[26]
Torvalds assigned version 0 to the kernel to indicate that it was mainly for testing and not intended for productive use.[27] Version 0.11, released in December 1991, was the first self-hosted Linux, for it could be compiled by a computer running the same kernel.
When Torvalds released version 0.12 in February 1992, he adopted the GNU General Public License version 2 (GPLv2) over his previous self-drafted license, which had not permitted commercial redistribution.[28] In contrast to Unix, all source files of Linux are freely available, including device drivers.[29] The initial success of Linux was driven by programmers and testers across the world. With the support of the POSIX APIs, through the libC that, whether needed, acts as an entry point to the kernel address space, Linux could run software and applications that had been developed for Unix.[30]
After version 1.3 of the kernel, Torvalds decided that Linux had evolved enough to warrant a new major number, so he released version 2.0.0 in June 1996.[39][40] The series included 41 releases. The major feature of 2.0 was support for symmetric multiprocessing (SMP) and support for more types of processors.
Starting with version 2.0, Linux is configurable for selecting specific hardware targets and for enabling architecture-specific features and optimizations.[30] The make *config family of commands of kbuild are used to enable and configure thousands of options for building ad hoc kernel executables (vmlinux) and loadable modules.[14][15]
Version 2.6.0 was released on 17 December 2003.[46] The development for 2.6.x changed further towards including new features throughout 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 architectures still limited to 215),[47] 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 a wide selection of file systems starting with the 2.6.x releases: now, the kernel supports a large number of file systems, some that have been designed for Linux, like ext3, ext4, FUSE, Btrfs,[48] and others that are native of other operating systems like JFS, XFS, Minix, Xenix, Irix, Solaris, System V, Windows and MS-DOS.[49]
In 2005 the stable team was formed as a response to the lack of a kernel tree where people could work on bug fixes, and it would keep updating stable versions.[50] In February 2008 the linux-next tree was created to serve as a place where patches aimed to be merged during the next development cycle gathered.[51][52] Several subsystem maintainers also adopted the suffix -next for trees containing code which they mean to submit for inclusion in the next release cycle. As of January 2014[update], the in-development version of Linux is held in an unstable branch named linux-next.[53]
Linux used to be maintained without the help of an automated source code management system until, in 2002, development switched to BitKeeper. It was freely available for Linux developers but it was not free software. In 2005, because of efforts to reverse-engineer it, the company which owned the software revoked its support of the Linux community. In response, Torvalds and others wrote Git. The new system was written within weeks, and in two months the first official kernel made using it was released.[54]
The 20th anniversary of Linux was celebrated by Torvalds in July 2011 with the release of the 3.0.0 kernel version.[39] As 2.6 had been the version number for 8 years, a new uname26 personality that reports 3.x as 2.6.40+x had to be added to the kernel so that old programs would work.[56]
On 11 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.[59][60] The same series unified support for the ARM processor.[61]
The numbering change from 2.6.39 to 3.0, and from 3.19 to 4.0, involved no meaningful technical differentiation. The major version number was increased to avoid large minor numbers.[57][64] Stable 3.x.y kernels were released until 3.19 in February 2015.
In April 2015, Torvalds released kernel version 4.0.[39] By February 2015, Linux had received contributions from nearly 12,000 programmers from more than 1,200 companies, including some of the world's largest software and hardware vendors.[65] Version 4.1 of Linux, released in June 2015, contains over 19.5 million lines of code contributed by almost 14,000 programmers.[66]
Linux distributions bundle the kernel with system software (e.g., the GNU C Library, systemd, and other Unix utilities and daemons) and a wide selection of application software, but their usage share in desktops is low in comparison to other operating systems.
Android, which accounts for the majority of the installed base of all operating systems for mobile devices,[73][74][75] is responsible for the rising usage of the Linux kernel,[30] together with its wide use in a large variety of embedded devices.
Most device drivers and kernel extensions run in kernel space (ring 0 in many CPU architectures), with full access to the hardware. Some exceptions run in user space; notable examples are filesystems based on FUSE/CUSE, and parts of UIO.[95][96] Furthermore, the X Window System and Wayland, the windowing system and display server protocols that most people use with Linux, do not run within the kernel. Differently, the actual interfacing with GPUs of graphics cards is an in-kernel subsystem called Direct Rendering Manager (DRM).
Unlike standard monolithic kernels, device drivers are easily configured as modules, and loaded or unloaded while the system is running and can also be pre-empted under certain conditions in order to handle hardware interrupts correctly and to better support symmetric multiprocessing.[79] By choice, Linux has no stable device driver application binary interface.[97]
Linux typically makes use of memory protection and virtual memory and can also handle non-uniform memory access,[98] however the project has absorbed μClinux which also makes it possible to run Linux on microcontrollers without virtual memory.[99]
Linux is a clone of UNIX, and aims toward POSIX and Single UNIX Specification compliance.[102] The kernel also provides system calls and other interfaces that are Linux-specific. In order to be included in the official kernel, the code must comply with a set of licensing rules.[6][11]
The Linux Application binary interface (ABI) between the kernel and the user space has four degrees of stability (stable, testing, obsolete, removed);[103] however, the system calls are expected to never change in order to not break the userspace programs that rely on them.[104]
Loadable kernel modules (LKMs), by design, cannot rely on a stable ABI.[97] Therefore, they must always be recompiled whenever a new kernel executable is installed in a system, otherwise they will not be loaded. In-tree drivers that are configured to become an integral part of the kernel executable (vmlinux) are statically linked by the building process.
There is also no guarantee of stability of source-level in-kernel API[97] and, because of this, device drivers code, as well as the code of any other kernel subsystem, must be kept updated with kernel evolution. Any developer who makes an API change is required to fix any code that breaks as the result of their change.[105]
The set of the Linux kernel API that regards the interfaces exposed to user applications is fundamentally composed of UNIX and Linux-specific system calls.[106] A system call is an entry point into the Linux kernel.[107] For example, among the Linux-specific ones there is the family of the clone(2) system calls.[108] Most extensions must be enabled by defining the _GNU_SOURCE macro in a header file or when the user-land code is being compiled.[109]
System calls can only be invoked by using assembly instructions which enable the transition from unprivileged user space to privileged kernel space in ring 0. For this reason, the C standard library (libC) acts as a wrapper to most Linux system calls, by exposing C functions that, only whether it is needed,[110] can transparently enter into the kernel which will execute on behalf of the calling process.[106] For those system calls not exposed by libC, e.g. the fast userspace mutex (futex),[111] the library provides a function called syscall(2) which can be used to explicitly invoke them.[112]
Pseudo filesystems (e.g., the sysfs and procfs filesystems) and special files (e.g., /dev/random, /dev/sda, /dev/tty, and many others) constitute another layer of interface to kernel data structures representing hardware or logical (software) devices.[113][114]
760c119bf3