Linux kernel facts for kids

Quick facts for kids
Linux kernel

Tux the penguin, mascot of Linux
Linux kernel 3.0.0 booting
Original author(s)	Linus Torvalds
Developer(s)	Community contributors Linus Torvalds
Initial release	0.02 (5 October 1991; 33 years ago (1991-10-05))
Stable release	6.11.2  / 4 October 2024
Preview release	6.12-rc2  / 6 October 2024
Written in	C (C11 since 5.18, C89 before), Rust (since 6.1), Assembly language
Available in	English
License	GPL-2.0-only with Linux-syscall-note

The Linux kernel is a core part of many computer systems around the world. Think of it as the brain of an operating system (OS). It helps the computer's hardware and software work together.

This kernel was created by Linus Torvalds in 1991. It is free and open source, meaning anyone can use, change, and share it. Soon after its creation, it became the kernel for the GNU operating system. Many operating systems today, often called Linux, use this kernel. Even Android, found on many phones and tablets, uses the Linux kernel!

Most of the Linux kernel is written in a programming language called C. It also uses assembly code for special tasks, like making the computer run faster. The kernel is designed in a way that allows different parts (called modules) to be added or removed while the system is running.

The Linux kernel is available under the GNU General Public License version 2, which means it's free to use and share, but any changes must also be shared under the same license.

History of the Linux Kernel

In April 1991, Linus Torvalds, a 21-year-old computer science student in Finland, started working on a new operating system. He was inspired by Unix, an older operating system. He began by creating a way for the computer to switch between different tasks and a basic terminal program.

On August 25, 1991, Linus shared his idea on a public online group called comp.os.minix:

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 protable [sic] (uses 386 task switching etc), and it probably never will support anything other than AT-harddisks, as that's all I have :-(.

On September 17, 1991, Torvalds released version 0.01 of Linux. It wasn't even fully working yet and needed another OS called Minix to compile. On October 5, 1991, he announced the first "official" version, 0.02.

[As] I mentioned a month ago, I'm working on a free version of a Minix-lookalike for AT-386 computers. It has finally reached the stage where it's even usable (though may not be depending on what you want), and I am willing to put out the sources for wider distribution. It is just version 0.02...but I've successfully run bash, gcc, gnu-make, gnu-sed, compress, etc. under it.

Linux quickly grew as many developers, including those from the MINIX community, started helping. The GNU Project was building a free Unix-like OS but didn't have a working kernel. They decided to use the Linux kernel for their project.

Linus initially called the kernel version 0 to show it wasn't ready for everyone. Version 0.11, released in December 1991, was the first version that could compile itself on a computer running Linux.

In February 1992, with version 0.12, Torvalds switched the license to the GNU General Public License version 2 (GPLv2). This license allowed people to share and even sell Linux, as long as they also shared the source code. Unlike Unix, all parts of Linux, including device drivers, were freely available.

Early success came from programmers and testers worldwide. Linux could run software made for Unix, which helped it become popular.

In 1992, a new online discussion group was created just for Linux, showing its growing community.

Linus Torvalds and Andrew S. Tanenbaum (the creator of MINIX) had a famous debate in 1992. They discussed whether a kernel should be "monolithic" (like Linux, where the whole OS runs in one big piece) or "microkernel" (where the OS is broken into smaller, separate parts).

Version 0.95 was the first to run the X Window System, which provides a graphical user interface. In March 1994, Linux 1.0.0 was released with over 176,000 lines of code. This was the first version considered ready for general use. In June 1996, after version 1.3, Linus decided Linux had grown enough for a new major version, so he released 2.0.0. This version added support for computers with multiple processors (SMP) and more types of CPUs.

Version 2.2, released in January 1999, improved how Linux handled multiple processors and added support for more 64-bit computer platforms. It also added support for new file systems, including reading Microsoft's NTFS files.

Version 2.4.0, released in January 2001, brought support for USB devices and PC Cards. It also supported newer processors like the Pentium 4. This version also added support for Bluetooth and improved storage features.

Version 2.6.0 was released in December 2003. This series of releases brought many new features, including better support for different CPUs, improved sound (ALSA), support for more users and devices, and better 64-bit support. It also added support for very large files (up to 16 terabytes) and improved security features.

The Linux kernel supports many different file systems, some made for Linux (like ext3, ext4, Btrfs) and others from different operating systems (like JFS, XFS, FAT32, and NTFS).

For a long time, Linux developers didn't use a special system to track changes to the code. In 2002, they started using a tool called BitKeeper. However, in 2005, the company that owned BitKeeper stopped supporting the Linux community. In response, Linus Torvalds and others quickly created a new version control system called Git. The first official kernel using Git was released just two months later.

In 2011, Linus Torvalds celebrated the 20th anniversary of Linux by releasing version 3.0.0. He said the big change was "NOTHING. Absolutely nothing." and that it was mainly a new number to avoid very large minor version numbers.

In 2012, Linus decided to simplify the kernel by removing support for older i386 processors. This made the 3.7 kernel series the last to support them. The same series also unified support for the ARM architecture processors, which are common in mobile devices.

The version number changes from 2.6.39 to 3.0, and from 3.19 to 4.0, didn't mean huge technical changes. It was mostly to keep the numbers from getting too big. Version 3.11, released in September 2013, added new features like better temporary file handling and improved power management for AMD graphics cards.

In April 2015, Torvalds released kernel version 4.0. By this time, nearly 12,000 programmers from over 1,200 companies had contributed to Linux. Version 4.1, released in June 2015, had over 19.5 million lines of code.

In March 2019, Linus Torvalds announced that kernel version 4.22 would be numbered 5.0. He joked that he "ran out of fingers and toes" for the 4.x numbers. This version brought many new features, including support for AMD Radeon FreeSync and NVIDIA Xavier displays.

Version 5.8 broke a record with 1,991 developers contributing, including 334 first-time helpers. They added over 553,000 lines of code.

How Popular is Linux?

Many websites use operating systems based on Linux. Also, all of the world's 500 most powerful supercomputers run some form of Linux-based OS.

Even though Linux is very popular for servers and supercomputers, it's not as common on desktop computers compared to other operating systems.

However, because Android (which uses the Linux kernel) is on most mobile devices, and its use is growing in embedded devices (like smart TVs or car systems), Android is a big reason for the overall rise in Linux use.

The Value of Linux

Experts have tried to estimate how much it would cost to recreate the Linux kernel if it were a traditional paid software project. In 2004, they estimated it would cost around US$612 million to redevelop version 2.6.0. By 2006, another study put the cost even higher, at €882 million (about $1.14 billion).

In 2008, the estimate for kernel 2.6.25 was $1.3 billion. By 2011, with the kernel growing, it was estimated to cost around $3 billion to redevelop. An updated calculation in 2018, based on over 20 million lines of code, suggested it would cost approximately $14.7 billion to rewrite the existing code. This shows the immense value of the free and open-source contributions to Linux.

How Linux is Shared

Most people use Linux through a "Linux distribution." These are complete operating systems that bundle the Linux kernel with other software, like tools and applications. Some distributions use the standard kernel, while others, like Red Hat and Debian, make their own changes. These customized versions might update slower but can include special drivers or features.

Who Develops Linux?

The Linux Community

The Linux kernel has a huge community of developers, around 5,000 to 6,000 people. A study from 2017 showed that about 1,500 developers from 200-250 companies contributed to recent kernel releases. The top 30 developers wrote about 16% of the code. Major companies like Intel and Red Hat are among the biggest contributors.

As Andrew Morton, a key developer, said in 2005:

Instead of a roadmap, there are technical guidelines. Instead of a central resource allocation, there are persons and companies who all have a stake in the further development of the Linux kernel, quite independently from one another:

People like Linus Torvalds and I don’t plan the kernel evolution. We don’t sit there and think up the roadmap for the next two years, then assign resources to the various new features. That's because we don’t have any resources. The resources are all owned by the various corporations who use and contribute to Linux, as well as by the various independent contributors out there. It's those people who own the resources who decide...

—Andrew Morton, 2005

Developer Conflicts

Sometimes, there have been disagreements among Linux kernel developers:

• In 2007, Con Kolivas stopped working on the kernel.
• In 2009, Alan Cox left his role as a maintainer after a disagreement with Linus Torvalds.
• In 2012, Torvalds openly disagreed with NVIDIA for keeping their drivers closed-source.
• In 2014, Torvalds stopped Kay Sievers from submitting patches due to bugs.
• In 2015, Christoph Hellwig sued VMware over copyright issues with the Linux kernel. Linus Torvalds disagreed with this action.
• In 2021, a team from the University of Minnesota submitted "bad faith" patches as part of research, leading to all their past patches being removed.

To help avoid conflicts, a "Code of Conflict" was introduced in 2015. This was replaced in 2018 by a new "Code of Conduct" based on the Contributor Covenant. This happened around the time Linus Torvalds apologized publicly and took a short break from kernel development. Developers who feel unfairly treated can report it to the Linux Foundation Technical Advisory Board.

How Linux is Developed

Linus Torvalds once said, "Linux is evolution, not intelligent design!"

The Codebase

The kernel's source code is managed using Git, a version control system also created by Torvalds. As of 2021, the Linux kernel had about 30.34 million lines of code. About 60% of this code is for "drivers," which help the kernel communicate with different hardware parts.

How Contributions are Made

Developers submit changes as "patches," which are like text messages sent to the Linux kernel mailing list (LKML). These patches follow specific rules and a special language that describes what code to add or remove. This allows system administrators to easily apply changes or upgrade to new versions.

Here's how it generally works:

• A developer writes and tests a code change.
• They send these changes as patches to the person who maintains that part of the kernel.
• The maintainer and others review the patches and give feedback.
• Once approved, the maintainer adds the patches to the kernel's Git tree.
• If the changes are important bug fixes, they are sent to Linus Torvalds quickly. Otherwise, they wait for the "merge window," which is a two-week period after a new kernel version is released.
• Linus Torvalds then merges these patches into the main kernel code.
• The kernel's Git tree lists all developers who have contributed.

Developers are expected to follow a code of conduct to ensure a respectful environment. They also use inclusive language in the code.

Programming Languages Used

Linux is mainly written in a special version of the C programming language that works with GCC. This compiler adds extra features to standard C, like allowing small sections of assembly language code directly within the C code.

In 2021, the kernel started using a newer C standard called C11. In December 2022, initial support for the Rust programming language was added in Linux 6.1, and this support has been improved in later versions.

Coding Style

Since 2002, all code added to the Linux kernel must follow specific rules called the Linux Kernel Coding Style.

Versioning

The kernel uses numbers like 4.16.1 to show its version.

• In the past, odd numbers (like 2.1) were for development, and even numbers (like 2.0) were for stable releases. This is no longer the case.
• The first two numbers together (e.g., 4.16) indicate the "major version."
• A suffix like -rcN (e.g., 4.16-rc1) means it's the Nth "release candidate" for the next version.
• Once a stable version is released, a "stable team" takes over its maintenance. Updates to a stable release are shown with three numbers (e.g., 4.16.1).

Tools Used for Development

The kernel is usually built using the GNU toolchain. This includes:

• GCC (GNU C compiler) to turn the C code into computer instructions.
• GNU make to manage the building process.
• GNU Assembler to create object files from assembly code.
• GNU Linker to combine all the pieces into a single executable kernel file called vmlinux.

For a long time, GCC was the only compiler that could correctly build Linux. Since 2010, developers have been working to build Linux with Clang, another C compiler. This project is called LLVMLinux. Using Clang can make compilation times shorter.

By 2017, Linux kernel 4.15 could be built with Clang. Google's Pixel 2 phone was the first to ship with a Clang-built Linux kernel. Today, the ClangBuiltLinux group helps ensure compatibility between Linux and LLVM (which Clang is built upon).

Debugging the Kernel

Like any complex software, the Linux kernel can have problems. These often relate to how different parts of the system access memory or manage hardware.

• An oops is a non-fatal error in the kernel. The system might keep running, but it could be unstable.
• A panic is a fatal error. The kernel prints a message and stops the computer.

Developers use several tools to find and fix bugs:

• printk(): This function prints messages that are stored in a special buffer.
• ftrace: This tool allows developers to monitor and debug Linux while it's running or even during startup.
• kprobes and kretprobes: These allow developers to "break into" kernel code and gather information without stopping the system.
• KGDB: This allows debugging Linux using another computer, similar to how user programs are debugged.

How Changes are Made

The Linux kernel project constantly adds new code. Any new software added must work and compile without errors.

Each part of the kernel has a "maintainer" who reviews new code and prepares it for Linus Torvalds. Linus then merges these changes into the main kernel code, creating a "release candidate" for the next stable version. Once the merge window closes, only bug fixes are accepted. The release candidate goes through testing, and when it's stable, a new version is released, and the process starts again.

Mainline Linux

The main Git tree containing the Linux kernel source code is called mainline Linux. All stable kernel releases come from this tree. Mainline Linux supports a basic set of devices. For many specific devices, independent projects or device vendors provide additional support.

It's often hard to maintain a kernel version that is separate from mainline Linux. "Mainlining" means adding support for a device or feature to the official mainline kernel, so it becomes a standard part of Linux.

Linux Forks

Sometimes, communities create their own versions of the Linux kernel, called "forks," based on the official one. Some interesting code from these forks has even been added back into the mainline Linux.

Many early mobile phone operating systems, like Google Android, used heavily changed versions of Linux. In 2010, the Linux community criticized Google for creating its own kernel tree, which made it hard to merge Android-specific drivers into the main kernel.

Today, Android still uses a customized Linux kernel, but Android developers also submit patches to the official Linux kernel so that it can eventually run Android. For example, a Nexus 7 tablet can now run the mainline Linux kernel.

Linus Torvalds explained in 2001 that different Linux distributions often make their own changes to the kernel. He sees this as a good thing because it shows that people are actively improving and adapting Linux for their needs. He also said that because of the GPL license, he can take the best parts from these different versions and add them to the standard kernel.

Long-term Support

The latest kernel versions and older ones are maintained separately. Linus Torvalds usually oversees the newest releases.

The Linux kernel community also maintains "stable" kernels by fixing bugs. The kernel.org website usually lists two stable kernels. A new stable Linux kernel is released every 8 to 12 weeks.

Some releases are marked for "long-term support" (LTS). These versions receive bug fixes for two or more years, which is helpful for systems that need to be very stable for a long time.

How Linux Works

The Linux kernel is both "monolithic" and "modular." It's monolithic because the entire operating system runs in one main area of the computer's memory (called "kernel space"). But it's also modular because different parts (called "modules") can be added or removed while the system is running.

Here are some key features of the Linux kernel:

• Multitasking: It can run many programs at the same time, even on computers with multiple processors.
• Configuration: You can choose and set up hundreds of kernel features and drivers before building it. You can also fine-tune its behavior while it's running.
• Task Scheduling: It decides which programs get to use the CPU and when. It uses a "Completely Fair Scheduler" (CFS) for normal tasks, making sure all programs get a fair share of CPU time. It also supports "real-time" scheduling for tasks that need to happen at very specific times.
• Memory Management: It handles the computer's memory, using "virtual memory" to make sure programs have enough space.
• Communication: It allows different programs to communicate with each other.
• File Systems: It supports many different ways to organize and store files.
• I/O Scheduling: It manages how data is read from and written to devices.
• Virtualization: It can run other operating systems inside it (like with KVM).
• Security: It has many features to keep the system safe, like SELinux and AppArmor.
• Networking: It supports various network protocols, including the Internet.

Most device drivers and kernel extensions run in "kernel space," giving them full access to the computer's hardware. However, some exceptions run in "user space." The X Window System and Wayland, which handle what you see on your screen, do not run inside the kernel itself.

Unlike some other kernels, Linux allows device drivers to be easily added or removed as "modules" while the system is running. This makes it very flexible.

Linux uses "memory protection" and "virtual memory" to keep programs from interfering with each other. However, it can also run on smaller microcontrollers that don't have virtual memory.

The hardware is represented in the file system. User programs interact with device drivers through special files in directories like /dev or /sys. Information about running programs is found in the /proc directory.

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

User mode	User applications	bash, LibreOffice, GIMP, Blender, 0 A.D., Mozilla Firefox, ...
	System components	init daemon: OpenRC, runit, systemd...	System daemons: polkitd, smbd, sshd, udevd...	Window manager: X11, Wayland, SurfaceFlinger (Android)	Graphics: Mesa, AMD Catalyst, ...	Other libraries: GTK, Qt, EFL, SDL, SFML, FLTK, GNUstep, ...
	C standard library	fopen, execv, malloc, memcpy, localtime, pthread_create... (up to 2000 subroutines) glibc aims to be fast, musl aims to be lightweight, uClibc targets embedded systems, bionic was written for Android, etc. All aim to be POSIX/SUS-compatible.
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	Networking subsystem
		Other components: ALSA, DRI, evdev, klibc, LVM, device mapper, Linux Network Scheduler, Netfilter Linux Security Modules: SELinux, TOMOYO, AppArmor, Smack
Hardware (CPU, main memory, data storage devices, etc.)

Kernel Interfaces

Linux started as a copy of Unix and aims to be compatible with POSIX and Single UNIX Specification standards. The kernel provides "system calls" and other interfaces that are specific to Linux. To be included in the official kernel, code must follow certain licensing rules.

The way the kernel interacts with user programs (called the "application binary interface" or ABI) is generally very stable. System calls are designed to never change, so older programs can still work on newer kernels.

However, "loadable kernel modules" (LKMs) cannot rely on a stable ABI. This means they must be recompiled every time a new kernel is installed.

There's no guarantee that the internal programming interfaces (API) within the kernel will remain stable. So, device driver code and other kernel parts must be updated as the kernel evolves.

Kernel-to-User Program Communication

The main way user programs talk to the Linux kernel is through system calls. A system call is a special request a program makes to the kernel. For example, the clone(2) system call is specific to Linux and helps create new processes.

Programs usually don't call these directly. Instead, they use the C standard library (libC), which acts as a go-between. When a program calls a function from libC, it might secretly ask the kernel to do something.

Special "pseudo filesystems" like sysfs and procfs, and "special files" like /dev/random or /dev/sda, also let programs interact with kernel data related to hardware or software devices.

Kernel-to-User Program Compatibility

Because there are many different versions of Linux operating systems, programs compiled for one Linux distribution might not always run on another. This is due to differences in kernel configurations, system libraries, and other software.

The Linux Standard Base (LSB) is a standard that tries to make Linux distributions more compatible. It covers not just the kernel but also other parts of the operating system.

Internal Kernel Communication

There are many internal programming interfaces (APIs) between different parts of the kernel. Some are only for internal use, while others are available to "loadable modules" (like device drivers) if they are specifically "exported."

Linux provides internal APIs that help manage data structures (like lists or trees) and perform common tasks (like copying data or allocating memory). These have been stable since Linux version 2.6.

Internal kernel APIs also include libraries for low-level services used by device drivers, such as:

• SCSI Interfaces and libATA for storage devices.
• Direct Rendering Manager (DRM) and Kernel Mode Setting (KMS) for graphics cards.
• DMA buffers for sharing memory between drivers.
• Video4Linux for video capture hardware.
• Advanced Linux Sound Architecture (ALSA) for sound cards.
• New API for network cards.
• mac80211 and cfg80211 for wireless network cards.

Internal Kernel Compatibility

Linux developers have chosen not to keep the internal kernel ABI (how different parts of the kernel talk to each other) stable. This means that modules compiled for one kernel version usually won't work with another version without being recompiled.

Multiprocessing

Linux creates new processes (running programs) or threads (smaller parts of a program) using system calls like clone(2). If a program uses shared libraries, a "dynamic linker" helps load them before the program runs.

The Native POSIX Thread Library (NPTL) provides a standard way for user programs to create and manage threads. The kernel also provides "futex" mechanisms for programs to lock and synchronize their actions, mostly in user space.

"Kernel threads" are special threads that run directly within the kernel itself.

Scheduling Tasks

The Linux "process scheduler" decides which program or task gets to use the CPU and for how long. It's modular, meaning it can use different scheduling methods. The scheduler checks different types of tasks and chooses the highest priority one that's ready to run.

Linux allows both "user preemption" (where the kernel can pause a user program) and "kernel preemption" (where the kernel can pause its own tasks). This makes Linux more responsive and better for desktop and real-time applications.

For normal tasks, Linux uses the Completely Fair Scheduler (CFS). This scheduler ensures that all running programs get a fair share of the CPU time, based on how much time they've already run and their priority.

The kernel also has "real-time" scheduling classes, like SCHED_FIFO and SCHED_RR, which are used for tasks that need to run at very precise times. These real-time tasks get priority over normal tasks. A newer policy called SCHED DEADLINE (added in kernel 3.14) has the highest priority of all.

In 2023, the CFS scheduler was replaced by the "Earliest Eligible Virtual Deadline First Scheduling" (EEVDF) scheduler in Linux kernel 6.6.

Synchronization

The kernel has many things happening at once (like interrupts, multiple processors, and different tasks). To prevent problems when different parts of the code try to access the same data at the same time, Linux provides tools like:

• Atomic types: Special variables that can only be changed by specific operations.
• Spinlocks: Small locks that prevent multiple parts of the code from running at the same time.
• Semaphores and Mutexes: Tools to control access to shared resources.
• Lockless algorithms: Ways to manage data without using locks, often relying on "memory barriers" to ensure correct order of operations.

Linux includes a tool called Lockdep to help find locking problems.

Interrupts

When hardware needs the kernel's attention (like when you type on the keyboard), it sends an "interrupt." The kernel handles interrupts in two parts:

• The "top half" is a quick routine that handles the immediate interrupt.
• The "bottom halves" (like softirq, tasklets, and work queues) do the longer tasks later.

Linux interrupt routines can be nested, meaning a higher priority interrupt can pause a lower priority one.

Memory Management

Linux uses "virtual memory" with "page tables" to manage memory. The kernel itself is always in physical memory and cannot be swapped to disk. If there's a memory error in the kernel, it can cause the system to crash. User program memory can be swapped to disk, but specific areas can be locked in memory.

Information about memory pages is stored in special data structures. The physical memory is divided into different zones based on how it's used.

Small pieces of memory can be requested by the kernel using functions like kmalloc(). Larger pieces are handled by vmalloc().

The kernel used to have different memory allocators, but now only the SLUB allocator remains. It's designed for simplicity and efficiency.

Supported Computer Architectures

Even though Linux wasn't originally designed to work on many different types of computers, it's now one of the most widely supported operating system kernels. It runs on everything from ARM architecture devices (like phones) to large mainframe computers. The first time Linux was adapted for a different computer type (Motorola 68000), Linus Torvalds had to make big changes to the code to make it easier to adapt for other computers in the future.

Linux is the main operating system on IBM's Summit, one of the world's fastest supercomputers. As of 2019, all of the world's 500 fastest supercomputers use some form of Linux.

Linux has also been adapted for various handheld devices, including older Apple's iPhone and iPod models.

Supported Devices

The LKDDb project started in 2007 to create a database of all hardware and protocols known by Linux kernels. Later, in 2014, the Linux Hardware project began collecting information about tested hardware configurations from Linux users.

Live Patching

Sometimes, updates can be applied to the kernel without needing to restart the computer. This is called "live patching." Technologies like Ksplice, kpatch, and kGraft allow this. Basic support for live kernel patching was added to the Linux kernel in version 4.0 in 2015. This allows kernel modules containing patches to be applied while the system is running.

Security

Bugs in the kernel can lead to security problems, like allowing someone to gain more control over the system or cause it to stop working. Over the years, many security bugs have been found and fixed. New features are also regularly added to improve the kernel's security.

Linux offers many ways to reduce security risks, known as Linux Security Modules (LSM). These include Security-Enhanced Linux (SELinux), originally developed by the NSA, and AppArmor. These modules help control what programs can do on the system.

Another security feature is Seccomp BPF, which filters what system calls user programs can make, reducing potential attack points.

Linus Torvalds believes that security bugs are just "normal bugs." He doesn't try to hide them, but he also doesn't think they should be treated as something special. He feels that focusing too much on "spectacular security holes" might make them seem more important than the many "boring normal bugs" that are actually more common and important to fix.

Linux distributions regularly release security updates to fix vulnerabilities in the Linux kernel. Many also offer "long-term support" releases, which receive security updates for a specific kernel version for many years.

Legal Aspects of Linux

Licensing Rules

Initially, Linus Torvalds released Linux under a license that didn't allow commercial use. However, with version 0.12, he switched to the GNU General Public License version 2 (GPLv2). This license allows people to share and sell modified or unmodified versions of Linux. However, it requires that all copies also be released under the same license, and that the complete source code must be provided or made available. Torvalds has said that licensing Linux under the GPLv2 was the "best thing I ever did."

The Linux kernel is specifically licensed under GNU General Public License version 2 only (GPL-2.0-only). This means you cannot choose to use a later version of the GPL. Any code contributed to the kernel must also be under a license compatible with the GPL.

There was a big discussion about whether the license could or should be changed to GPL version 3. Linus Torvalds made it clear that his own code is only under version 2. Many key kernel developers also preferred GPLv2 over GPLv3, citing concerns about certain clauses in GPLv3 related to DRM and patents.

Loadable Kernel Modules

There's a debate about whether some loadable kernel modules (LKMs) should be considered "derivative works" under copyright law, which would mean they fall under the GPL.

According to the license, LKMs that only use a public part of the kernel's interfaces are not considered "derived works." This means Linux allows system administrators to load binary programs (not source code) into the kernel's memory space.

However, Linus Torvalds has stated that "binary-only kernel modules ARE derivative 'by default'." He also said that a "gray area" exists for drivers originally written for other operating systems, as they might not be considered derived works of Linux. Proprietary graphics drivers are often discussed in this context.

When proprietary modules are loaded into Linux, the kernel marks itself as "tainted." This means that developers might ignore bug reports from such kernels because the problem could be with the proprietary module, not the kernel itself.

Firmware Binary Blobs

The official Linux kernel (from kernel.org) includes "binary blobs," which are pieces of code that are not open source but are released under the GPLv2 license. Linux can also search for and load other binary blobs, like proprietary firmware or drivers, into the kernel's memory.

Sometimes, firmware (software that controls hardware) is built directly into the kernel for faster access. However, this isn't always possible due to technical or legal reasons, especially if the firmware is not GPL-compatible.

Trademark

"Linux" is a registered trademark of Linus Torvalds in the United States, the European Union, and other countries. A legal dispute over the trademark began in 1996 when a lawyer tried to charge fees for using the word "Linux." After it was shown that the word was commonly used before his claim, the trademark was given to Torvalds.

See also

In Spanish: Núcleo Linux para niños