Tagged articles
system-calls
71 articles · Page 1 of 1
This comprehensive guide traces the full execution path of a Linux program from user-space glibc calls through system calls into the kernel, covering process management, memory allocation, threading, I/O buffering, dynamic linking, and practical debugging techniques.
Linux internalsLinux kerneldebugging
0 likes · 61 min read

The article explains how frequent Linux system calls cause costly context switches, kernel checks, and cache/TLB invalidations, presents benchmark code that quantifies the overhead of getpid, open, read, and demonstrates batch I/O, caching, and algorithmic techniques to dramatically reduce those calls and boost high‑performance C++ network services.
CachingI/O batchingLinux
0 likes · 28 min read

The article explains why conventional read/write loops cause excessive user‑kernel switches and data copies that inflate CPU usage and limit throughput for large or high‑frequency file transfers, and it presents zero‑copy and asynchronous I/O techniques with complete C++ examples to eliminate these bottlenecks.
C++File I/OLinux
0 likes · 20 min read

Although Linux pipes avoid disk I/O and seem faster, misuse such as tiny frequent writes, mismatched read/write speeds, non‑blocking tight loops, and improper fd handling can drive a single core to 100 % CPU, but the article explains the underlying reasons and step‑by‑step optimizations to prevent it.
CPU usageIPCLinux
0 likes · 17 min read

The article explains that system calls are triggered by CPU‑provided privileged instructions (e.g., int 0x80, syscall, svc), with compilers translating high‑level calls into these instructions, and why user‑mode programs cannot access hardware directly for security reasons.
CPUCompileroperating system
0 likes · 6 min read

This article walks through the complete Linux file I/O workflow—from opening, reading, and writing files, to kernel‑level system call execution and the differences among five major I/O models—explaining buffers, caches, blocking vs. non‑blocking modes, and performance‑impacting trade‑offs.
BuffersFile I/OI/O Models
0 likes · 42 min read

This comprehensive guide explains Linux system calls—the sole interface between user‑space programs and the kernel—covering their purpose, core logic for process, file, and memory management, the underlying interrupt mechanisms, parameter handling, and real‑world C code examples.
LinuxProcess Managementc-programming
0 likes · 53 min read

This article explains the fundamental differences between user mode and kernel mode in Linux, why the separation matters for security and stability, how mode switches occur via system calls, interrupts, and traps, and provides practical code examples and performance‑optimizing techniques such as zero‑copy and asynchronous I/O.
Linuxkernelperformance
0 likes · 49 min read

This article provides a comprehensive, step‑by‑step explanation of Linux process management, covering the definition of a process, PCB structure, task organization, state transitions, creation system calls (fork, vfork, clone), execution with exec, scheduling, waiting, termination, and the kernel’s resource allocation strategies.
LinuxProcess Managementexec
0 likes · 43 min read

This article explains the fundamentals of Linux memory management, details how shared memory implements zero‑copy inter‑process communication, and provides step‑by‑step code examples of system calls, mmap, sendfile, splice, and synchronization techniques for high‑performance data transfer.
IPCShared Memorymemory management
0 likes · 40 min read

This article provides a comprehensive guide to Linux TCP development, explaining the role of system calls, the three‑way handshake and four‑way termination, detailing core socket functions such as socket, bind, listen, accept, connect, read/write, recv/send, and includes complete example code for building a simple TCP server and client with troubleshooting tips.
C++LinuxTCP
0 likes · 41 min read

This article thoroughly explains Linux shared memory, covering its advantages over other IPC methods, the kernel data structures, virtual‑physical mapping, creation and destruction APIs, copy‑on‑write behavior, and provides complete example code for inter‑process communication.
IPCShared Memoryc-programming
0 likes · 46 min read

This article explains the purpose of Linux's separate signal stack, how it differs from the regular process stack, the mechanics of signal delivery, practical code examples for enabling and using it, and why it matters for stability, real‑time processing, multithreading, and performance optimization.
LinuxSIGSTKSZSignal Stack
0 likes · 28 min read

This article explains what POSIX is, its history, the organizations behind it, how it shaped Linux's success, and why understanding system calls versus library functions is essential for writing portable software across Unix‑like operating systems.
LinuxPOSIXoperating-systems
0 likes · 17 min read

This article explains Linux system calls as the bridge between user‑space programs and the kernel, covering their purpose, importance, the distinction between user and kernel space, the execution process, classifications, invocation methods, and performance considerations, with clear examples in C.
Linuxkernelprogramming
0 likes · 50 min read

This article explores the evolution of Linux I/O models—from blocking and non‑blocking to epoll—and introduces io_uring as a high‑performance asynchronous framework that reduces system‑call overhead, eliminates data copies, and unifies network and disk I/O for modern high‑concurrency applications.
Linux kernelasynchronous I/Oio_uring
0 likes · 51 min read

This article explains the low‑level mechanisms of brk and mmap in Linux, compares their characteristics, shows why malloc selects one over the other based on allocation size, and provides practical code examples, performance tips, and common pitfalls for developers.
Linuxbrkmalloc
0 likes · 29 min read

The article explains how frequent user‑kernel mode switches in Linux create hidden performance bottlenecks, describes the underlying privilege mechanisms on x86 and ARM, details the three switch triggers (system calls, hardware interrupts, traps), and provides practical optimization techniques such as reducing syscalls, using zero‑copy APIs, async I/O, DPDK, and kernel‑module examples to improve throughput.
Linuxkernelperformance
0 likes · 71 min read

This article explains the fundamentals of malloc and free, covering their signatures, how they interact with the brk/sbrk system calls, the structure of memory control blocks, multiple allocation strategies such as explicit free lists, segregated lists, buddy systems and tcmalloc, along with code examples and their trade‑offs.
Dynamic Memoryc-programmingfree
0 likes · 15 min read

mmap maps files directly into a process’s virtual memory, eliminating the double‑copy between kernel and user space and reducing costly read/write system calls, which boosts I/O performance, simplifies code, but requires careful handling of address space limits, page faults, and concurrency.
I/O performancememory mappingmmap
0 likes · 8 min read

This article explains what Linux system calls are, why they are essential for resource management, process control and device access, describes the separation of user and kernel space, details the execution flow of a system call, and provides multiple C code examples for direct and library‑based invocation.
Linuxc-programmingsystem-calls
0 likes · 34 min read

This article explains how mmap maps files into a process's virtual memory to eliminate double data copies and reduce system‑call overhead, offering performance gains, a simpler programming model, and discusses its limitations such as address‑space constraints and page‑fault latency.
I/O performanceLinuxmemory mapping
0 likes · 8 min read

This article dissects Linux’s inotify mechanism, detailing the kernel data structures, system‑call flow, and functions that generate and deliver file‑system event notifications, complete with code walkthroughs and diagrams. It explains how read/write operations trigger event creation, how events are queued in inotify_device, and how user‑space processes retrieve them via read and poll interfaces.
File MonitoringLinux kernelevent handling
0 likes · 14 min read

This article explains how Linux processes are created, managed, and replaced using the fork, wait (including waitpid), and exec system calls, covering their prototypes, return values, copy‑on‑write optimization, and practical C code examples that demonstrate their coordinated use in real‑world scenarios.
Linuxc-programmingexec
0 likes · 25 min read

This guide explains what strace is, how it leverages ptrace to intercept system calls, shows installation steps, demonstrates basic and advanced usage patterns, discusses real‑world scenarios, interprets output formats, highlights performance trade‑offs, and compares alternative tracing tools.
Performance Analysislinux debuggingptrace
0 likes · 9 min read

This article explains the inner workings of the classic strace command by walking through a hand‑crafted C program that uses ptrace to attach to a target process, set syscall tracing, wait for signals, read the ORIG_RAX register, and translate syscall numbers into readable names, while also discussing the performance impact of such tracing.
Linuxptracestrace
0 likes · 16 min read

This article explains the purpose, prototype, and usage of C's malloc function, delves into its underlying implementation using free‑list mechanisms, virtual‑memory translation, system calls like brk and mmap, and compares it with related functions such as calloc, realloc and new, while providing practical code examples and best‑practice guidelines.
C++Dynamic Memoryfree
0 likes · 32 min read

This article explains why Chinese desktop operating systems struggle with software availability, compares virtual machines with Wine, and details how Wine’s compatibility layer leverages portable CPU instructions and system‑call interception to run Windows programs on Linux efficiently.
Compatibility LayerLinuxWindows compatibility
0 likes · 8 min read

This article explains how Linux creates processes using fork, vfork, clone and pthread_create, reveals the role of the init process, explores clone flags and namespace checks in the kernel, and shows why understanding these fundamentals demystifies container startup.
Linuxcontainerfork
0 likes · 7 min read

This article explains Go's uintptr type, its definition, typical scenarios such as cgo interaction and system calls, provides Linux and Windows code examples, and highlights key differences from regular pointers to help developers use it safely and effectively.
GoLow-Level ProgrammingUnsafe
0 likes · 6 min read

This article explains how Linux system calls serve as the primary interface between user‑space programs and the kernel, describes the transition from user mode to kernel mode, and provides step‑by‑step debugging examples and source‑code snippets for x86_64 architectures.
Linuxassemblykernel debugging
0 likes · 31 min read


21CTOMar 11, 2024 · Operations
Linux kernel 6.8, the GA release for Ubuntu 24.04 LTS, brings a suite of hardware enablements, driver updates, performance enhancements, and new system calls, while maintaining an average size and focusing on incremental improvements across graphics, memory management, networking, and security.
hardware supportkernel 6.8performance improvements
0 likes · 8 min read

This article explains the fundamentals of sockets as a network communication abstraction, covering process communication, TCP/UDP protocols, socket descriptors, key system calls, the TCP three‑way handshake and four‑way termination, Linux kernel basics, and provides complete C examples for a server and client.
C++LinuxSocket
0 likes · 45 min read

This guide explains what a process is, how it differs from a thread, various ways to create and terminate processes in Linux, and provides detailed examples of inter‑process communication mechanisms—including message queues, shared memory, UNIX domain sockets, pipes, and semaphores—complete with C code samples.
C++IPCLinux
0 likes · 31 min read


21CTOAug 20, 2023 · Fundamentals
This tutorial walks you through creating a simple Unix shell in C, covering its lifecycle, input handling, command parsing, process launching, built‑in commands, and full source compilation, while providing complete code examples and explanations.
C++Tutorialshell
0 likes · 19 min read

This article provides a comprehensive overview of the Linux kernel, explaining its core responsibilities, memory and process management, device drivers, system calls, and security, followed by detailed guidance on kernel modules, common commands such as uname, lsmod, modinfo, modprobe, depmod, and practical steps for compiling and configuring the kernel.
LinuxModulessystem-calls
0 likes · 24 min read

This article provides a comprehensive analysis of how JDK NIO performs file read and write operations by examining the underlying Linux kernel mechanisms, including the differences between Buffered and Direct IO, the structure and management of the page cache, file readahead algorithms, and the kernel parameters governing dirty page writeback.
Buffered IOFile I/OJDK NIO
0 likes · 78 min read

This article explains the fundamental concepts of Linux processes, their relationship to programs, threads, kernels, and memory, details the internal task_struct implementation, and walks through the full lifecycle from creation with fork, loading via execve, execution, and termination including exit_group and zombie handling.
LinuxProcess Managementkernel
0 likes · 49 min read

This article examines three Linux user‑kernel communication methods—ioctl, proc, and Netlink—by describing their principles, presenting experimental setups and code, measuring nanosecond‑level call latency, and offering guidance on selecting the most suitable mechanism for a project.
Netlinkioctlproc
0 likes · 8 min read

This article explains Linux storage hierarchy, the roles of user‑space and kernel caches, the three‑layer I/O stack, page‑cache synchronization policies, file‑operation atomicity, locking mechanisms, and performance testing techniques for HDD and SSD devices.
I/OLinuxPage Cache
0 likes · 16 min read

This guide explains Linux file I/O fundamentals, covering file concepts, standard streams, system calls like open and dup2, file descriptor allocation, redirection, the FILE structure, inode layout, hard and soft links, and the creation and usage of static and dynamic libraries, all illustrated with code snippets and diagrams.
Dynamic LibraryFile I/OInode
0 likes · 22 min read

This tutorial walks through Linux file programming fundamentals, covering how to open, create, read, write, and manipulate file descriptors and cursor positions with system calls like open, creat, read, write, lseek, and close, and demonstrates practical examples such as implementing a cp command, editing configuration files, and using both low‑level and standard C library I/O functions.
File I/OPOSIXc-programming
0 likes · 28 min read

The article dissects Linux’s epoll I/O multiplexing, tracing the flow from socket creation with accept through epoll_create, epoll_ctl registration, and epoll_wait sleeping, detailing the kernel’s eventpoll object, red‑black tree, per‑socket wait‑queue callbacks that enable O(log N) registration and O(1) event delivery for tens of thousands of connections.
C++EpollIO Multiplexing
0 likes · 24 min read

A dramatized Linux security incident shows how administrators use commands like top, ps, netstat, and the unhide tool to discover hidden mining processes, isolate suspicious network connections, and finally terminate the malicious hidden PID, illustrating practical techniques for rootkit detection and response.
Linuxprocess hidingrootkit detection
0 likes · 7 min read

Traditional Linux I/O using read() and write() involves multiple CPU and DMA copies and context switches, while modern techniques like zero‑copy, multiplexing, and page‑cache optimization reduce overhead; this article explains the classic I/O flow, read/write operations, network and disk I/O, and high‑performance strategies such as zero‑copy and Direct I/O.
I/OLinuxPageCache
0 likes · 12 min read

This article explains the classic Linux read/write system‑call I/O path, the copy and context‑switch overhead involved, and presents high‑performance techniques such as zero‑copy, multiplexing, and PageCache optimizations to reduce latency and improve throughput.
I/OLinuxPageCache
0 likes · 13 min read

This article explains how Linux implements traditional system‑call I/O using read() and write(), details the data‑copy and context‑switch overhead of read and write operations, describes network and disk I/O, and introduces high‑performance techniques such as zero‑copy, multiplexing, and page‑cache optimizations.
I/OLinuxPage Cache
0 likes · 12 min read

This article provides an in‑depth overview of Linux I/O mechanisms, covering the memory hierarchy pyramid, kernel‑level caching layers, the Linux I/O stack, page‑cache synchronization strategies, file‑operation atomicity, locking, and practical disk performance testing techniques.
I/OLinuxPage Cache
0 likes · 18 min read

Traditional Linux I/O relies on read() and write() system calls that involve multiple CPU and DMA copies and context switches, while modern optimizations such as zero‑copy, multiplexing, and page cache techniques reduce copying overhead, and understanding buffered, mmap, and direct I/O reveals their impact on performance.
I/OLinuxPage Cache
0 likes · 12 min read

This article traces the real system‑call flow of Java’s I/O models—BIO, NIO, Netty and AIO—on CentOS 7.5, compares their performance, lists advantages and disadvantages, and shows how each model interacts with the Linux kernel via strace.
AIOIOJava
0 likes · 23 min read

This article analyzes the actual Linux system calls performed by various Java I/O models—including BIO, NIO, epoll‑based multiplexing, Netty, and AIO—showing code examples, performance trade‑offs, and how each approach interacts with the kernel.
I/OJavaNetty
0 likes · 24 min read

This article explains the concepts of user space and kernel space, shows how traditional file‑to‑socket transfers involve multiple data copies with read/write system calls, and demonstrates how the Linux sendfile system call implements zero‑copy to reduce copies and system calls for high‑performance servers.
Backend PerformanceLinuxsendfile
0 likes · 6 min read

This guide explains what strace is, how to use it for filtering system calls, profiling execution time, diagnosing configuration issues, and tracing network activity, providing concrete command examples and interpretation of output to help troubleshoot Linux processes efficiently.
Linuxdebuggingperformance profiling
0 likes · 16 min read

This article explains the internal workings of Linux pipes, named pipes (FIFOs), and signal handling, covering their kernel implementation, synchronization mechanisms, relevant system calls, and provides concrete C code examples for creating and using these inter‑process communication primitives.
IPCLinuxSignals
0 likes · 17 min read

This article explains the distinction between kernel space and user space in a 32‑bit Linux system, covering address layout, privilege levels, mode transitions, system calls, and the overall OS structure to illustrate how separating these spaces enhances stability and security.
Kernel SpaceLinuxProcess Management
0 likes · 10 min read

This article explains Linux's file system architecture, covering basic directory structures, absolute and relative paths, symbolic links, the Virtual File System layer, core system calls such as creat, open, read, write, lseek, locking mechanisms, and the design of ext2, ext4, /proc, and NFS file systems.
EXT4Ext2Linux
0 likes · 34 min read

This article explains how a 32‑bit operating system divides its 4 GB address space into kernel and user regions, why this separation protects system stability, how kernel and user modes differ, and the mechanisms—such as system calls—that let processes move between them.
Kernel SpaceLinuxProcess Management
0 likes · 10 min read


ITPUBSep 27, 2020 · Fundamentals
This article provides a comprehensive overview of Linux file system architecture, covering basic concepts, directory structures, absolute and relative paths, linking, VFS abstraction, ext2/ext4 implementations, locking mechanisms, key system calls, and network file systems like NFS, illustrating how they interact within the kernel.
EXT4Ext2Linux
0 likes · 35 min read

This article provides a comprehensive overview of Linux file systems, covering VFS, directory hierarchy, absolute and relative paths, symbolic links, mounting, file locking, and the essential system calls such as creat, open, read, write, lseek, stat, pipe, and fcntl.
LinuxVFSdirectory structure
0 likes · 18 min read

This article provides a comprehensive overview of Linux fundamentals, covering process and thread concepts, various inter‑process communication mechanisms, essential system calls, process descriptors, scheduling algorithms such as O(1) and CFS, synchronization primitives, and the operating system boot sequence.
IPCLinuxScheduling
0 likes · 34 min read

The article explains Linux kernel virtual memory management on 64‑bit ARM64 Android systems, detailing user‑ and kernel‑space address layout, physical vs. linear addresses, allocation mechanisms such as brk and mmap, common allocators, key structures like mm_struct and vm_area_struct, and the functions that control mmap layout and unmapped‑area selection.
ASLRKernel Internalsarm64
0 likes · 20 min read

This comprehensive guide explains the fundamentals of operating systems, covering hardware components, CPU architecture, memory hierarchy, process and address space management, file systems, system calls, and various OS structures such as monolithic, layered, microkernel, and client‑server designs, providing clear examples and diagrams for each concept.
OS ArchitectureProcess Managementfile-system
0 likes · 68 min read

This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.
LinuxShared Memorycopy-on-write
0 likes · 9 min read

This article introduces essential programming fundamentals, covering Unix system architecture, the distinction between system calls and library functions, user and kernel modes, the execution flow of a simple hello‑world program, and core concepts such as processes, threads, coroutines, and parent‑child process sharing.
Coroutinesoperating systemprocesses
0 likes · 7 min read

This article compiles 35 Linux operations interview questions—including multiple‑choice, coding, and essay topics—along with detailed answers covering VLANs, system calls, IP addressing, TCP/UDP, process handling, data structures, and networking fundamentals to help candidates prepare effectively.
InterviewLinuxNetworking
0 likes · 18 min read

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.
Androidkernelseccomp
0 likes · 6 min read


ITPUBSep 4, 2017 · Fundamentals
This article explains the core functions of the Linux kernel, covering system calls, file abstraction, process scheduling, module management, the /proc virtual filesystem, and practical command‑line tools such as lsmod, modprobe, modinfo, and sysctl, with clear code examples.
Kernel ModulesModprobecommand-line
0 likes · 14 min read


ITPUBNov 1, 2016 · Information Security
This article explains the mechanics of Linux buffer‑overflow attacks with concrete C and assembly examples, shows how to craft and execute shellcode, and demonstrates practical mitigation techniques such as using Libsafe with LD_PRELOAD to protect vulnerable programs.
LD_PRELOADLibsafeLinux-security
0 likes · 23 min read

This guide shows ops engineers how to shift from routine maintenance to DevOps expertise by adopting the right mindset, mastering open‑source community resources, contributing code, and understanding design patterns, concurrency, modularity, data structures, algorithms, and system calls.
Operationsdesign patternssource code
0 likes · 14 min read

This article explains what strace is, how it works via ptrace, and demonstrates its practical use in diagnosing service startup failures, process exits, shared‑memory errors, and performance bottlenecks through detailed examples and common command‑line options.
LinuxPerformance Analysisstrace
0 likes · 14 min read

This article demonstrates how to use strace, including its -c, -T, and -e options, to identify kernel‑level system calls such as clone that cause high CPU consumption in PHP processes on a Linux server, providing step‑by‑step commands and interpretation of the results.
LinuxPHPperformance debugging
0 likes · 4 min read
