The article walks through the Linux packet lifecycle—from the send() system call, through the transport and network layers, to the NIC driver—explaining each step, virtual‑network abstractions, and the essential bandwidth, latency, loss, conntrack, and socket buffer metrics to monitor when problems arise.
sk_buff is the backbone of Linux’s network stack, handling packet storage, metadata, memory management and protocol‑layer interactions; this article dissects its structure, pointer model, core operations, packet lifecycle, practical code examples, and common pitfalls such as memory shortage, data loss and performance bottlenecks.
This comprehensive tutorial walks through the Linux networking stack—from basic concepts, physical and data‑link layers, and addressing schemes to routing protocols, TCP/UDP transport mechanisms, application‑layer services like DNS and HTTP, and security fundamentals—providing clear explanations, step‑by‑step processes, formulas, and visual diagrams to help readers understand how each layer works and interacts.
This article explains how subtle misconfigurations in the Linux kernel network protocol stack can cause high latency, walks through the stack’s layered architecture, details TCP/UDP mechanisms, and provides practical troubleshooting steps with tools like ethtool, ss, tcpdump, Wireshark, and bpftrace.
This article explains how traditional kernel network stacks struggle with high‑concurrency, low‑latency cloud data‑center workloads and introduces Baidu Intelligent Cloud’s Polar solution—Polar‑TCP and Polar‑RDMA—which combine user‑space DPDK drivers, a lightweight TCP stack, and an industrial RPC framework to achieve near‑RDMA performance while preserving compatibility with existing TCP ecosystems.
This article explains how traditional kernel network stacks struggle with modern cloud data‑center workloads and introduces Baidu Intelligent Cloud's Polar solution—Polar‑TCP and Polar‑RDMA—which combine user‑space DPDK drivers, a lightweight TCP stack, and an industrial‑grade RPC framework to achieve near‑RDMA performance while preserving ecosystem compatibility.
This article demystifies the Linux kernel by explaining its core subsystems—process scheduling, memory management, virtual file system, networking, and device drivers—while offering practical learning paths, essential commands, code examples, and curated resources for anyone wanting to master Linux internals.
This article walks through every stage a network packet undergoes inside the Linux kernel—from hardware interrupt and driver processing, through the sk_buff structures of the TCP/IP stack, to user‑space delivery—while explaining zero‑copy mechanisms like sendfile, splice, mmap and io_uring, and offering concrete tuning commands for optimal performance.
This article explores the Linux kernel’s network stack architecture, detailing each layer from the application’s socket interface through transport, network, and link layers, and explains the complete inbound and outbound data flow with code examples illustrating packet reception, processing, routing, and transmission.
This article explains Linux networking fundamentals, comparing the OSI and TCP/IP models, detailing the Linux network stack architecture, packet encapsulation, reception and transmission processes, and introduces essential commands for monitoring network performance and socket statistics.
This article explains Linux networking fundamentals, covering the OSI and TCP/IP models, the Linux network stack layers, packet encapsulation, MTU considerations, and practical commands such as ifconfig, ip, netstat, ss, and ping for performance monitoring and troubleshooting.
The article examines the scalability limitations of the Linux kernel TCP/IP stack, comparing its packet‑processing and connection‑setup performance with user‑space stacks such as mTCP and F‑Stack, explains how hash‑table locking and spin‑lock contention cause poor CPS scaling, and argues why user‑space implementations often achieve higher throughput despite their own trade‑offs.
Linux processes network packets through a layered TCP/IP stack, starting with hardware DMA into a ring buffer, handling interrupts, traversing the network interface, IP, transport, and application layers on receive, and reversing the flow for sending, with detailed steps for each layer and driver interaction.
This article explains the step‑by‑step process Linux uses to receive and transmit network packets, covering the initialization of the network subsystem, the role of the ring buffer, interrupt handling, and the layered processing through the TCP/IP stack from the NIC up to the application.
This article explains the Linux network stack, detailing the TCP/IP model layers and describing in depth how incoming packets travel from the NIC through DMA, interrupt handling, and the kernel's protocol layers to the application, as well as the reverse path for outgoing packets.
This article explains the step‑by‑step process Linux follows to receive network packets from the NIC, pass them through the kernel’s networking stack, and finally deliver them to applications, as well as the reverse path for sending packets from applications to the network.
Linux handles network traffic through a layered TCP/IP stack, where incoming packets travel from the NIC’s DMA‑filled ring buffer through interrupt handling, protocol layers, and finally to the application, while outgoing packets follow the reverse path, with each layer adding its own headers and processing.
This article presents a detailed guide for optimizing large‑scale Apache Flink streaming jobs on the JD Real‑Time Computing platform, covering TaskManager memory model tuning, network stack configuration, RocksDB state management, checkpoint strategies, and additional performance tips with practical examples and calculations.
The article explains how the Linux kernel implements the TCP three‑way handshake, detailing server listen queue allocation, client connect port selection and SYN transmission, SYN‑ACK processing, state transitions, request‑socket management, full‑connection queue handling, and the final accept call, plus tuning tips.
The article examines the evolution of Tencent Cloud’s F-Stack—a full user‑space networking framework built on DPDK, FreeBSD, and micro‑threading—detailing its architecture, supported versions, POSIX‑compatible API, real‑world deployments such as HttpDNS and DNSPod, performance gains over kernel stacks, and the roadmap for future enhancements.
This article explains the layered architecture of the Linux network subsystem, the TCP/IP model implementation, how hardware and soft interrupts are registered and processed, the role of ksoftirqd and NAPI, and the complete send/receive packet flow from NIC to protocol stack.
This article explains the Linux network subsystem architecture, the TCP/IP layering, and the complete path a packet takes from NIC interrupt handling through soft‑irqs, NAPI, and kernel threads to the protocol stack, while also detailing driver registration and send/receive workflows.
This article outlines the key features of Windows Server 2022 LTSC—including enhanced security with TPM 2.0 and VBS, default HTTPS/TLS 1.3, SMB AES‑256 encryption, network stack improvements, Hyper‑V virtualization upgrades, and the switch to Chromium Edge as the default browser—while noting Microsoft’s new multi‑year support model.
This article explains the layered architecture of the Linux network stack, maps the TCP/IP model to Linux implementation, and details how hardware and soft interrupts, ksoftirqd threads, and NAPI cooperate with driver initialization to process packet reception and transmission.
This article provides a deep, step‑by‑step analysis of how Linux 3.10 processes a send() call—from user‑space socket handling through TCP, IP routing, queueing, driver DMA mapping, and both hard and soft interrupt handling—answering why CPU time appears in sy/si, why NET_RX softirqs dominate, and what memory copies occur during transmission.
This comprehensive article provides an in-depth analysis of how Linux kernel sends network packets, covering the complete process from user-space send() call through protocol stack processing to hardware transmission, with detailed source code examination and performance considerations.
This article provides a detailed, step‑by‑step walkthrough of the Linux kernel’s packet‑receiving path, covering NIC DMA, hardware and soft interrupts, ksoftirqd threads, NAPI polling, protocol‑stack registration, IP/UDP processing, and the final recvfrom system call that delivers data to user space.
This article explains how Linux implements the TCP/IP model to encapsulate, transmit, and receive network packets, covering OSI vs TCP/IP layers, the Linux network stack structure, NAPI interrupt mitigation, and the step‑by‑step processing of packets in both directions.
This article walks through the complete Linux kernel path a network packet follows—from the NIC’s DMA and hardware interrupt, through soft‑interrupt handling, NAPI polling, protocol‑stack registration, IP and UDP processing, all the way to the user‑space recvfrom system call—revealing the many hidden steps that make packet reception possible.
This article examines Flink’s industrial‑scale network stack, detailing the credit‑based flow control introduced in version 1.5, the refactored task‑IO thread collaboration, and serialization optimizations that together improve throughput and latency for large‑scale stream processing workloads.
This article walks through every step from pressing a key on the keyboard to the browser rendering a web page, covering hardware signaling, kernel interrupt handling, DNS resolution, TCP handshakes, HTTP exchange, and final page display, illustrating how many university‑level concepts intersect in a single URL request.
This article introduces the open‑source Contiki operating system for IoT, detailing its history, core features such as memory management and network stacks, source‑level modules, as well as its advantages, drawbacks, and why its ready‑to‑use development environment remains valuable for embedded developers.
