Tagged articles
file-descriptors
39 articles · Page 1 of 1
This article presents a systematic, hypothesis-driven methodology for tuning Linux kernel parameters to improve Nginx concurrency, covering file descriptor limits, listen queue configuration, network buffer tuning, and safe canary deployment with rollback procedures, all validated through metrics and load testing.
ConcurrencyLinux kernelNGINX
0 likes · 25 min read

This article explains why df reports high disk usage while du shows much less, revealing that deleted files held open by processes consume space, and demonstrates how to identify and release these ghost files using lsof and /proc/pid/fd/ without restarting services.
Linuxdfdisk space
0 likes · 5 min read

When df reports 98% disk usage but du accounts for only 50%, the missing space is typically held by a process that deleted a file but kept its file descriptor open; this article demonstrates how to locate the offending process with lsof, reclaim space instantly via /proc/pid/fd, and prevent recurrence by truncating logs instead of removing them.
Linuxdisk troubleshootingfile-descriptors
0 likes · 6 min read

The article explains how Linux limits on file descriptors, memory consumption per socket, and TCP four‑tuple theory together determine the practical maximum number of TCP connections a server or client can handle, and shows how to tune kernel parameters to increase that limit.
LinuxMemoryTCP
0 likes · 17 min read

This article explains the Linux kernel limits that determine how many files and TCP connections a server can handle, shows how to adjust fs.file-max, soft/hard nofile and fs.nr_open parameters, calculates realistic connection counts based on memory, and discusses client‑side port constraints and practical scaling scenarios.
LinuxNetworkingTCP
0 likes · 15 min read

This article explains the theoretical and practical limits of TCP connections on a Linux server, covering kernel parameters such as fs.file-max, soft/hard nofile and fs.nr_open, memory constraints, client port limits, and step‑by‑step configuration examples to maximize concurrent connections.
LinuxNetworkingTCP
0 likes · 14 min read

This article explains the Linux kernel parameters that limit the number of open files and TCP connections, shows how to adjust them, estimates realistic connection counts based on memory, and discusses client‑side port constraints and related practical issues.
LinuxTCP connectionsfile-descriptors
0 likes · 14 min read

This article explains the Linux kernel parameters that limit the number of open files and TCP connections on a server, shows how to calculate practical limits based on memory and configuration, and provides step‑by‑step examples for adjusting those limits safely.
LinuxNetworkingTCP connections
0 likes · 15 min read

This article explains the practical limits on how many TCP connections a Linux server or client can support, covering file‑descriptor parameters, memory consumption per socket, kernel tuning examples, and scaling calculations for large‑scale long‑connection services.
LinuxTCPconnection limits
0 likes · 15 min read

This article explains Linux redirection, the three standard streams and their file descriptors, how to adjust descriptor limits, practical redirection examples, and the fundamentals of pipes—including anonymous and named pipes, their characteristics, and typical use cases for inter‑process communication.
IPCLinuxRedirection
0 likes · 13 min read

This guide explains how to permanently disable SELinux, set the system runlevel, enlarge file descriptor limits, fine‑tune kernel networking parameters via /etc/sysctl.conf, configure firewall settings, and troubleshoot common Linux socket errors to significantly improve server performance.
LinuxNetwork SettingsPerformance Tuning
0 likes · 7 min read

Learn how to optimize Linux server performance by permanently disabling SELinux, setting runlevel 3, increasing file descriptor limits, fine-tuning kernel network parameters via /etc/sysctl.conf, configuring firewall settings, and addressing common issues like too many open files and TIME_WAIT overloads.
file-descriptorsserver optimization
0 likes · 8 min read


ITPUBDec 10, 2024 · Operations
Linux treats everything as a file, so the maximum number of open files and TCP connections a server can support depends on kernel parameters like fs.file-max, soft/hard nofile, and fs.nr_open, as well as memory size, port limits, and proper configuration to avoid 'too many open files' errors.
LinuxTCP connectionsfile-descriptors
0 likes · 15 min read

This article debunks the common myth that a server can only handle 65,536 TCP connections by exploring the theoretical four‑tuple limits, practical constraints like file descriptors, port ranges, and memory/CPU usage, and explains how the true upper bound is far larger.
LinuxTCPfile-descriptors
0 likes · 5 min read

This article explains Linux redirection, the three standard data streams (stdin, stdout, stderr), file descriptors, how to adjust their limits, common redirection syntax, and the concepts, types, and usage of both anonymous and named pipes for inter‑process communication.
LinuxRedirectioncommand-line
0 likes · 12 min read

This article explains the Linux kernel limits that determine how many files and TCP connections a server can open, shows how to tune fs.file-max, soft/hard nofile, and fs.nr_open, estimates realistic connection counts based on memory, and provides practical configuration examples for large‑scale services.
LinuxNetworkingTCP
0 likes · 16 min read

This comprehensive guide explains how to use the Linux lsof command to list information about open files, directories, sockets, and devices across processes, covering options for filtering by file, process, user, network connections, and advanced features like repeat mode and combined queries.
LinuxNetwork Connectionsfile-descriptors
0 likes · 11 min read

This guide explains how to use the lsof command on Linux to list open files, filter by process, directory, user, or network criteria, combine options, view UNIX domain sockets, count open files, and even recover accidentally deleted files using file descriptors.
Linuxfile-descriptorslsof
0 likes · 12 min read

This article uses a playful story of a Linux process to explain the real limits on TCP connections, covering the configurable port range, file descriptor caps, thread model constraints, memory usage, and CPU saturation, and shows how to adjust these limits on a Linux server.
IO MultiplexingLinuxPort Range
0 likes · 13 min read

This article explains Linux file concepts, how file descriptors work, why simple blocking I/O fails at scale, and introduces I/O multiplexing techniques—including select, poll, and epoll—detailing their mechanisms, limitations, and practical code examples for high‑concurrency servers.
EpollI/O multiplexingfile-descriptors
0 likes · 13 min read

This article explains how Linux kernel parameters, memory size, and file descriptor limits determine the maximum number of TCP connections a server or client can handle, provides configuration examples for increasing those limits, and discusses practical considerations such as port ranges and connection overhead.
LinuxNetworkingOperations
0 likes · 15 min read

This article explains the Linux parameters that limit the maximum number of open files and TCP connections on a server, shows how to adjust those limits with configuration examples, and discusses practical constraints such as memory, port ranges, and real‑world scaling scenarios.
Linuxfile-descriptorsnetwork performance
0 likes · 15 min read

This article explains the origins and purpose of Linux's standard input (0), standard output (1), and standard error (2) file descriptors, shows how they are defined in Rust and Go, and illustrates their behavior in terminal emulators and SSH sessions with detailed diagrams.
GoLinuxRust
0 likes · 11 min read

This article explains how Linux limits the number of open files and TCP connections on a server, details the key kernel parameters (fs.file-max, soft/hard nofile, fs.nr_open), provides configuration examples, and analyzes how memory and port ranges determine realistic connection capacities for both servers and clients.
LinuxTCPfile-descriptors
0 likes · 16 min read

This article explains the Linux kernel limits that determine how many files a server can open and how many TCP connections it can sustain, covering the key parameters (fs.file-max, soft/hard nofile, fs.nr_open), practical configuration examples, memory constraints, client-side limits, and related performance considerations.
LinuxTCP connectionsfile-descriptors
0 likes · 15 min read

This article explains the Linux kernel limits that determine how many files and TCP connections a server can open, describes the key parameters (fs.file-max, soft nofile, fs.nr_open), shows configuration examples, and discusses how memory, ports, and other settings affect real‑world capacity for both servers and clients.
LinuxTCP connectionsfile-descriptors
0 likes · 14 min read

This article explains the Linux kernel parameters that limit open files and TCP connections, shows how to increase those limits with sysctl and limits.conf, and estimates the maximum number of concurrent connections a server or client can support based on memory and port constraints.
LinuxOperationsTCP connections
0 likes · 14 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 article explains why Linux imposes resource limits, shows how to inspect user‑level limits with ulimit, demonstrates practical experiments to increase file‑descriptor and stack limits via /etc/security/limits.conf, and outlines system‑wide constraints and tools like prlimit for robust server programming.
LinuxResource LimitsStack Size
0 likes · 7 min read

This article explains why the “Too many open files” error occurs on Linux, analyzes the three related kernel parameters (fs.nr_open, nofile, and fs.file-max), shows the relevant source code, and provides step‑by‑step configuration guidance to safely increase file descriptor limits.
Linuxfile-descriptorssystem limits
0 likes · 12 min read

This article explains the true limits of concurrent TCP connections on a server, debunks common misconceptions about port numbers, details the TCP four‑tuple theory, outlines Linux file‑descriptor restrictions, shows how to tune kernel buffers with sysctl, and shares a real‑world test achieving one million active connections.
ConcurrencyLinuxTCP
0 likes · 6 min read


ITPUBDec 31, 2020 · Operations
This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.
ConcurrencyLinuxTCP
0 likes · 7 min read

This article explains the true limits of simultaneous TCP connections on a single Linux server, debunking common myths about the 65,535 port ceiling, detailing kernel and user‑level file‑descriptor restrictions, sysctl buffer settings, and a practical experiment achieving one million concurrent connections.
LinuxNetwork ConnectionsTCP
0 likes · 7 min read

This guide explains how to install the lsof utility on Linux, interpret its output, filter results with grep or process IDs, handle permission limitations, and use options like +c, -i, -n, and -P to display full process names and network connections.
file-descriptorslsofnetwork sockets
0 likes · 8 min read


ITPUBJan 8, 2020 · Fundamentals
The article explains Unix's core design that treats files, devices, sockets, and pipes as unified resources accessed via file descriptors, discusses the abstraction trade‑offs, and pays tribute to the pioneers behind these concepts while illustrating the ideas with several diagrams.
Linuxfile-descriptorsoperating-systems
0 likes · 3 min read

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.
Shared MemorySystem Monitoringfile-descriptors
0 likes · 9 min read

This article analyzes a production incident where a Java web application using Apollo configuration center encountered "Too many open files" errors, detailing the fault symptoms, root cause analysis involving Tomcat's classloader and file‑descriptor limits, and presenting remediation and preventive measures.
ApolloClassLoaderJava
0 likes · 13 min read


ITPUBDec 29, 2015 · Backend Development
This tutorial walks you through creating a simple iterative Python web server, demonstrates its single‑request limitation, explains socket fundamentals, and then shows how to transform it into a concurrent server using the Unix fork() system call while handling backlog, duplicate descriptors, and zombie processes.
Socketsfile-descriptorsfork
0 likes · 18 min read

This guide explains how to boost Linux server performance and harden security by tuning disk, network, memory, and file‑descriptor parameters with sysctl, ulimit, and iptables commands, providing practical examples and explanations for each setting.
Linuxfile-descriptors
0 likes · 17 min read
