The article explains that kernel code must copy user‑space buffers with copy_from_user rather than using memcpy, covering the necessity of copying, the built‑in access checks, page‑fault handling, security implications, and modern hardware safeguards like PAN.
This article provides a comprehensive, illustrated explanation of how Linux receives network packets—from hardware DMA and interrupt handling through soft‑interrupt processing, NAPI polling, protocol stack registration, and finally delivery to user‑space via recvfrom—detailing each kernel component and relevant source code.
This comprehensive guide explores Linux’s four core components—kernel, shell, filesystem, and applications—detailing kernel architecture, memory and process management, VFS, device drivers, network interfaces, shell types, file types, directory structures, mounting, and essential command-line tools for system administration.
This guide shows a quick user‑space technique to conceal a Linux process by overwriting its PID with an unused value using a short SystemTap script, includes the exact code, execution steps, detection method, and a brief explanation of why it works.
This comprehensive guide walks through Linux's core components—including the kernel, shell, and file system—explaining memory and process management, VFS architecture, partition types, mounting procedures, common commands, and optimization tips, all illustrated with diagrams and practical examples.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, shell, memory and process management, virtual file system, various file system types, directory structures, partitioning, mounting procedures, and link mechanisms, offering readers a solid foundation for mastering Linux systems.
This comprehensive guide explores Linux's core components—including the kernel, shell, memory and process management, file systems, device drivers, network interfaces, mounting mechanisms, and link types—providing clear explanations, diagrams, and command examples for anyone learning operating system fundamentals.
This article walks through the design and implementation of a tiny Linux filesystem called TinyFS, explaining the VFS layers, required POSIX interfaces, data structures, core kernel code, usage steps, current limitations, and a roadmap for extending it with proper superblocks, concurrency, and page‑cache integration.
This article explains how Linux organizes a process's address space into text, data, and stack segments, describes virtual memory concepts such as paging, page tables, and page faults, and details the kernel's allocation, deallocation, and memory‑mapping mechanisms including brk, mmap, and the buddy allocator.
This article details how to diagnose and resolve Nginx load‑balancing performance issues under extreme concurrency by analyzing NIC packet loss, kernel SYN drops, backlog limits, and applying systematic kernel, network‑card, and Nginx configuration optimizations that raise QPS from 20,000+ to over 40,000.
This comprehensive guide explores Linux memory fundamentals, address space layout, fragmentation, buddy and slab allocation algorithms, kernel and user‑space memory pools, DMA handling, common pitfalls in C/C++ memory management, and practical commands for monitoring and debugging memory usage on Linux systems.
This article explains the Linux CPU‑idle framework, detailing the idle governor architecture, the entry and exit flow, key data structures, and the menu governor’s prediction and correction algorithms that balance power savings with performance latency.
This article provides a comprehensive guide to Linux memory management, covering the memory organization, address spaces, fragmentation causes and mitigation, the buddy and slab allocation algorithms, kernel and user‑space memory pools, common pitfalls, and practical tools for monitoring and debugging memory usage.
This comprehensive guide explores Linux memory architecture, address spaces, paging, fragmentation, buddy and slab allocation algorithms, kernel and user‑space memory pools, DMA handling, practical usage scenarios, and common pitfalls, providing developers with actionable insights to optimize system performance.
The article explains how Android’s mount command shows numerous dm devices, detailing the Linux storage stack layers, using the OPPO Reno3 as a case study to illustrate the creation and purpose of dm devices, and poses why dm‑0 disappears from Android versions after Q.
Linux system calls provide the interface between user programs and the kernel, and this article explains the three implementation methods—software interrupts, fast syscall instructions (SYSENTER/SYSCALL), and the virtual dynamic shared object (vDSO)—detailing their operation, performance impact, and relevant assembly code examples.
sdcardfs is a kernel-space stackable virtual file system built on wrapfs, replacing FUSE on Android O, offering better I/O performance by reducing user‑kernel transitions and avoiding double caching, while not managing actual SD cards; it forwards operations directly, achieving near‑native speeds.
This article provides a comprehensive overview of Linux, covering its four main components—kernel, shell, file system, and applications—detailing kernel responsibilities such as memory and process management, the role of the virtual file system, device drivers, networking, shell types, file types, directory structures, disk partitioning, mounting mechanisms, hard and symbolic links, and essential command‑line tools for system administration.
This comprehensive guide explains over 190 fundamental operating system and computer architecture concepts—including OS kernels, memory management, process control, virtualization, storage, networking, and security—providing clear definitions, examples, and visual illustrations to help readers grasp the core building blocks of modern computing systems.
This article explains how Linux maps logical to physical addresses, describes the buddy and slab memory allocation mechanisms, outlines their limitations and improvements such as slub and vmalloc, and details the page‑fault handling process including registers involved and swap behavior.
This article explains how a simple read of a single byte in user space triggers a complex Linux I/O stack involving the read system call, VFS, page cache, generic block layer, and I/O scheduler, and clarifies when actual disk I/O occurs and how many bytes are transferred.
This article explains Linux’s layered filesystem architecture, detailing how generic API calls like read interact with the VFS, superblock, inode, dentry, and buffer cache, and demonstrates mounting a filesystem using loop devices, dd, losetup, mke2fs, and mount commands.
The article explains the design and operation of Linux’s BFQ (Budget Fair Queueing) I/O scheduler, its algorithmic advantages over CFQ, performance test results, and the reasons it outperforms other schedulers, concluding with its growing adoption in major projects.
This article provides a comprehensive overview of operating system fundamentals and computer architecture, covering topics such as OS components, kernel and user modes, memory management, process handling, hardware interfaces, storage hierarchies, virtualization, and related historical and modern systems in roughly eighty concise entries.
This article explains how Linux kernels receive network packets—from NIC hardware interrupts through NAPI polling, kernel TCP/IP processing, and finally to user‑space sockets—while also covering interrupt handling, buffer tuning, and performance‑optimizing techniques for SREs.
This article explains the Linux kernel's wait‑queue mechanism, the sleep and wake‑up logic behind socket events, and how the IO‑multiplexing models select, poll, and epoll are implemented, including their core code paths, performance trade‑offs, and edge versus level triggering.
The Linux 5.3 series receives its final maintenance release (5.3.18) with 59 file changes, after which support ends, prompting users and distro maintainers to upgrade to the newer 5.4 kernel, which introduces long‑awaited exFAT filesystem support and the Lockdown security feature.
A four‑year‑old girl submitted a one‑character patch to the Linux kernel that added a dash for proper alignment, illustrating the openness of the kernel project, the meticulous nature of its codebase, and the surprising impact of even the smallest contributions.
This article provides a comprehensive analysis of Linux's epoll mechanism, covering its fundamental data structures, key kernel functions, wait‑queue handling, event insertion, wake‑up logic, and the differences between edge‑triggered and level‑triggered modes, while including full source code excerpts for reference.
An extensive guide walks through Linux’s core components—kernel, memory and process management, VFS, device drivers, networking, shells, filesystem hierarchy, partitioning, mounting, and link types—detailing their structures, key commands, and practical examples for system administrators and developers.
This comprehensive guide explains the core components of a Linux system—including the kernel, memory management, process scheduling, device drivers, networking, shells, file‑system types, VFS architecture, mounting procedures, and link handling—providing clear examples, commands, and diagrams for each topic.
This article provides an in‑depth exploration of Linux’s timekeeping subsystem, covering how the kernel initializes and maintains system time, reads timestamps via vDSO and sequential locks, manages timers with various algorithms, and explains the underlying quartz crystal oscillator that generates the hardware clock.
The article details how Ctrip engineers diagnosed sporadic Redis timeouts in containerized deployments, traced the problem to kernel scheduling delays caused by an APIC‑ID bug that inflated the possible‑CPU count, and resolved it by applying a kernel patch, offering verification steps for affected systems.
This article explores Linux kernel memory management, detailing process address space allocation, the behavior of the OOM killer, various memory mapping types (shared, private, anonymous), cache usage, manual and automatic memory reclamation, and related kernel parameters, providing practical insights and examples.
This article provides a comprehensive, step‑by‑step explanation of how Linux load averages are calculated, how to dissect them with scripts like load2process, and how to use kernel modules and monitoring techniques for precise performance analysis and troubleshooting.
This article explains the principle, implementation, configuration, and practical performance impact of Linux Kernel Samepage Merging (KSM), showing how it reduces memory usage in containerized game services while outlining integration costs, risks, and monitoring guidelines.
This article traces the evolution of operating systems—from early UNIX and BSD to embedded kernels like VxWorks and μClinux, culminating in the rise of Linux—highlighting key concepts, architectural differences, and why mastering Linux fundamentals is essential for every developer.
This article explains how the Linux kernel manages memory reclamation, the role of kswapd, the distinction between file and anonymous pages, the impact of swap and the swappiness parameter, and provides practical guidance for tuning swap usage in production systems.
This article explains the motivations behind Cgroups v2, outlines its unified hierarchy design, details the five key improvements over v1, describes controller management, subtree control, event and stat files, and provides practical commands for mounting and configuring the new cgroup subsystem.
This article explains the background of Linux cgroups, outlines the key differences between v1 and v2—including the unified hierarchy, controller handling, and new control files—and provides practical commands and examples for using cgroups v2 in container environments.
This article explains how Linux kernels 2.6 and 4.18 manage CPU power‑saving P‑states and C‑states, compares energy‑saving and performance modes, and details the underlying idle drivers, BIOS settings, and performance impacts on Intel Xeon E5‑2630 v4 CPUs.
This article explains the step‑by‑step boot sequence of a computer—from the BIOS reading the MBR on the selected storage device, through the boot loader loading the kernel, to the kernel initializing hardware, spawning the init process, and finally presenting the login screen.
This article explains a whimsical comic that visualizes the Linux kernel as a multi‑layered house, detailing the foundation of file cabinets, the process table, key system processes like init, cron, Apache and SSH, the role of TTY terminals, and related Linux concepts.
Linux Kernel 5.0, recently released after seven release candidates, brings modest enhancements such as AMD open‑source GPU driver updates, FreeSync support, a new perceptual scheduler for ARM big.LITTLE power management, Adiantum encryption for low‑power devices, Btrfs swap, UDP GRO, cgroupv2 cpuset, and binderfs for multiple Android instances, alongside numerous driver additions and bug fixes.
Linus Torvalds, born in Helsinki in 1969, created the Linux kernel in 1991 after experimenting with MINIX and writing his own disk driver, championing free software principles that now power billions of devices—from servers to Android phones—while his controversial personality sparked intense community debates.
This article explains the Linux load average metric, the run queue structure, why both running (R) and uninterruptible (D) processes are counted, and how the kernel uses an exponential weighted moving average to compute the 1‑, 5‑, and 15‑minute load values.
This article explains how Linux processes transition between running, sleeping, and waking states, describes interruptible and uninterruptible sleep, demonstrates code for putting a process to sleep and waking it, and provides strategies to prevent invalid wake‑up scenarios caused by race conditions.
Linux Kernel 4.20, the largest release in over a year, arrived just before Christmas, bringing major updates such as BPF network parsing, new hardware support, C‑SKY architecture, pressure‑stall detection, XArray data structures, and early NVIDIA HDMI 2.0 driver support.
This guide shares a self‑taught developer’s experience on transitioning to Linux application development, covering essential command learning, the distinction from operations, a clear definition of Linux app development, and a step‑by‑step roadmap for mastering bootloader, kernel, driver, and root‑filesystem development.
This article explains why traditional function‑hooking tricks fail on modern Linux due to executable‑memory protections, and presents a step‑by‑step method using page‑table remapping and the kernel's text_poke utilities to replace kernel functions safely, complete with code examples and a diagram.
This article provides a comprehensive overview of Linux fundamentals, covering the kernel architecture, virtual memory management, process scheduling and inter‑process communication, the hierarchical file system and VFS layer, device drivers, networking, shell variants, partitioning, mounting, and essential command‑line tools.
This article explains Linux kernel memory management from a global perspective, covering process address space layout, memory allocation mechanisms, OOM handling, the location of allocated memory, cache behavior, tmpfs usage, and the kernel's automatic memory reclamation strategies.
This article demystifies the computer boot process, explaining how power‑on triggers BIOS, which loads the MBR, boot loader, kernel, init scripts, and finally presents the login screen, helping readers understand and troubleshoot each fragile stage.
Linux is a free Unix‑like kernel originally written for 386‑AT computers, described by Linus Torvalds in 1991, covering its source‑code licensing, hardware requirements, download sources, installation steps, missing features, and early ported utilities, offering a historical snapshot of early open‑source OS development.
This 1991 article by Linus Torvalds explains what Linux is, its free Unix‑like kernel, licensing terms, required 386‑AT hardware, how to obtain the source via FTP, step‑by‑step installation, missing features, ported utilities, and ways to get technical help.
This article surveys the evolution, core concepts, and concrete implementation details of Linux task scheduling, illustrating kernel data structures, scheduling entities, run‑queue management, and the CFS algorithm with code excerpts and explaining how the scheduler balances interactive and background workloads.
The article explains the discrepancy between the file‑handle count reported by /proc/sys/fs/file‑nr and the numbers shown by lsof, clarifying the difference between file descriptors and file handles, describing how the kernel allocates struct file objects, and showing how shared memory, mmap, and other operations can inflate handle counts unnoticed by lsof.
This article explains three ways to perform Linux system calls—using glibc wrapper functions, the low‑level syscall interface, and inline assembly with the int 0x80 instruction—illustrating each method with a chmod example, error handling, and code snippets.
This article explains Linux kernel memory management, covering process address space layout, memory allocation, OOM handling, where allocated memory resides, and both manual and automatic memory reclamation techniques, with practical examples and visual illustrations.
The article explains that Windows often slows down due to accumulated service entries, registry I/O, and micro‑kernel design that loads many sys files at boot, whereas Linux’s monolithic kernel and fewer services keep its performance more stable over long use.
This comprehensive guide covers Linux fundamentals, explaining GNU's role, system components, kernel subsystems, memory addressing, process management, interrupt handling, system calls, synchronization mechanisms, file systems, and device drivers, providing clear answers to common questions for learners and developers.
This article provides a comprehensive overview of Linux fundamentals, covering distribution choices, kernel architecture, core components, filesystem types, standard directory hierarchy, shell usage, and common applications for both server and desktop environments.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, shell, file system, memory management, process scheduling, device drivers, networking, partitioning, mounting, and common command‑line tools, offering readers a solid foundation in operating‑system fundamentals.
Linus Torvalds publicly rebuked recent kernel security hardening attempts, arguing that such changes often introduce bugs, should be deferred until final review, and that many security developers act irrationally, sparking a heated debate on the Linux mailing list.
During the debate over new features for Linux kernel 4.15, Linus Torvalds harshly rejected security‑hardening changes proposed by Kees Cook, calling them unnecessary bugs and criticizing the approach of killing processes to enforce new rules.
This guide walks you through the fundamentals of Linux kernel upgrades, covering kernel anatomy, compilation steps, configuration tuning, kernel migration, and creating RPM packages for streamlined, reliable updates across multiple servers.
Linux kernel 4.14 LTS “Fearless Coyote” introduces heterogeneous memory management, expanded x86_64 memory limits, Vega improvements, Zstd compression, AMD secure memory encryption, new Realtek driver, HDMI‑CEC support on Raspberry Pi, Android F2FS tuning, and various Btrfs, EXT4 and XFS enhancements, while Linus Torvalds highlights a modest shortlog and upcoming changes for 4.15.
This article explains why Weave's FastDb mode can cause network interruptions on CentOS 7 VMs, analyzes the underlying kernel bugs and UDP PMTU probing issues, and provides practical solutions such as kernel upgrades, disabling UFO, and adjusting MTU settings.
This article introduces ten common Linux kernel processes, explaining their roles—from memory management with kswapd0 to I/O handling by aio—helping operators and developers recognize and interpret the often‑bracketed system daemons that appear in ps listings and affect system performance.
The article traces the origins of Unix, its various branches such as BSD, System V, and modern derivatives like XNU, AIX, Solaris, and Linux, highlighting key historical milestones, licensing, and the impact of open‑source releases on developers.
Apple surprised developers by publishing the XNU kernel source for macOS and iOS on GitHub, explaining the kernel’s origins, licensing under APSL 2.0, and how this move may help developers understand system internals while aiming to attract more contributors.
The article explains how Android O uses seccomp filters in the zygote process to block unused or dangerous system calls, how developers can detect and avoid illegal calls that cause crashes, and how to test or disable the filter on development builds.
This article details UDB's high‑availability architecture and four kernel‑level optimizations—binlog replication, relay‑log recording, master.info handling, and relay‑log locking—that together improve MySQL semi‑synchronous replication performance and reliability.
This article explains Linux interrupt handling mechanisms, covering the basic vector‑table approach, the concept of bottom‑half processing, and the evolution from simple interrupt routines to softirqs, tasklets, and workqueues, while offering practical guidance on when to use each technique.
This article explains the need for virtual memory in Linux, describes its implementation mechanisms such as swap space and lazy allocation, and details the typical layout of the kernel and user address spaces, including high‑memory handling and zone mapping.
This article explains how to locate the Linux 2.2.5 i386 kernel source, describes the bootloader (bootsect-loader) and its related files, and walks through both real‑mode and protected‑mode initialization steps, including parameter tables and memory layout, to help readers understand the OS startup process.
This article walks through how the Samsung S3C2410 clocks are defined, linked to parent clocks, and finally registered in the Linux kernel via a chain of initialization functions, illustrating each step with source‑code excerpts and diagrams.
This article walks through the Linux kernel's clock management code, explaining how the clk_get_sys function matches devices, handles mutexes, and enables clocks on Samsung platforms, while illustrating each step with annotated code screenshots.
This article explains why the Linux kernel introduced the tasklet mechanism, details its core data structures and execution flow, and then compares it with the workqueue system, covering creation, scheduling, and processing of work items in kernel space.
This article explains the components of the Linux kernel, the design philosophies behind it, and provides a step‑by‑step walkthrough of the CentOS boot sequence—from POST and BIOS to GRUB stages, kernel initialization, run‑level configuration, and final user‑space startup.
This article explains Linux kernel memory management by describing how user‑level malloc allocates virtual memory, how page tables map virtual to physical addresses, and how the hardware‑triggered page‑fault mechanism ultimately provides the needed physical pages.
This article explains the Linux kernel architecture, key components, and the detailed CentOS boot sequence—from hardware POST and BIOS to GRUB stages, kernel initialization, runlevel configuration, and system initialization scripts—providing a comprehensive overview of OS startup fundamentals.
This article explains the distinction between hard IRQ and soft IRQ in the Linux x86 32‑bit kernel, detailing how preempt_count tracks interrupt context, how do_IRQ, irq_enter, and irq_exit manage the transition, and how __do_softirq processes pending softirqs with code examples and diagrams.
This article explains Linux kernel interrupt handling in five stages—from acquiring the interrupt number and serializing concurrent interrupts to using softirqs, tasklets, and workqueues for deferred processing—while highlighting the design choices that keep critical code non‑reentrant and the system responsive.
The article explains how the Linux kernel identifies processes stuck in the uninterruptible D state, describes the hung‑task detection code, shows the watchdog thread and related functions, and provides a Raspberry Pi example that triggers and logs a hung‑task warning.
This article explains the two-stage process by which the Linux kernel parses memory information passed from U‑Boot—first via ATAG tags and then through the boot command line—detailing the relevant code, data structures, and practical methods for modifying memory size on embedded platforms.
This article provides an in‑depth technical overview of Linux Netfilter, explaining its hook architecture, key macros, packet‑processing flow, and how iptables interacts with the kernel to filter, NAT, and track connections across the IPv4 stack.
This article examines the kernel‑mode iSCSI Enterprise Target (IET), detailing its component modules (ietadm, ietd, iscsi_trgt), the interaction flow between initiators and the target, and the internal I/O processing pipeline, including thread allocation, work queues, and backend storage handling.
This article explains why the Linux kernel has succeeded, describing its layered position in a computer system, the roles of virtualization and multitasking, the overall modular architecture, key data structures, and the design of core subsystems such as the process scheduler, memory manager, virtual file system, and network interface.
This article explains the complete Linux boot sequence, detailing how POST, BIOS, the MBR bootloader, GRUB stages, the kernel, initrd, and the init process work together to detect hardware, load drivers, mount the root filesystem, and start system services.
This article explains Linux kernel interrupt handling, top‑half and bottom‑half mechanisms, IRQ request/release, shared IRQs, disabling/enabling IRQs, tasklets, workqueues, softirqs, the timer API, and provides a complete character‑device driver example with a user‑space test program.
This guide walks you through obtaining the Linux kernel source, extracting it, configuring options with menuconfig, compiling with make, installing modules and the kernel, updating bootloader entries, and cleaning up, providing practical commands and tips for a successful custom kernel build.
The article details the official CentOS 7.0.1406 64‑bit release announced on July 7, 2014, highlighting kernel upgrades, container support, default JDK, installation media options, verification steps, major changes, downgrade options, known issues, and where to obtain source code and ISO images.
