If you’ve ever managed a high-traffic web server (e.g., Nginx, Apache), a database (MySQL, PostgreSQL), or any daemon handling thousands of concurrent connections, you’ve likely encountered the frustrating too many open files error. This occurs when a process exceeds its maximum limit of open file descriptors (FDs)—a core resource Linux uses to track files, sockets, pipes, and other I/O objects.A natural instinct is to ask:Can I just set the maximum open files limit to unlimited to avoid this issue?The short answer is:No, unlimited isn’t truly unlimited—but youcanset extremely high limits by understanding Linux’s underlying constraints.In this guide, we’ll demystify file descriptor limits, explain why unlimited is a misnomer, and walk through step-by-step methods to adjust limits for daemons. Whether you’re running a production service or troubleshooting FD-related errors, this guide will help you optimize your system safely.Nov 28, 20252025-11Table of Contents#Understanding File Descriptors and LimitsWhat Are File Descriptors?Soft vs. Hard LimitsPer-Process vs. System-Wide LimitsChecking Current LimitsFor Your Shell SessionFor a Running DaemonSystem-Wide LimitsCan You Really Set Unlimited? The TruthKernel-Level ConstraintsWhy Unlimited Is CappedAdjusting Limits for Daemons: Step-by-StepTemporary Adjustments (Not Recommended for Daemons)Permanent Adjustments withlimits.conf(PAM)Systemd Services:LimitNOFILE(Best for Modern Daemons)System-Wide Kernel Tuning (sysctl)Verifying the ChangesRisks and Best PracticesAvoiding Resource ExhaustionMonitoring File DescriptorsApplication-Specific LimitsConclusionReferences1. Understanding File Descriptors and Limits#Before adjusting limits, let’s clarify what file descriptors are and how Linux manages them.What Are File Descriptors?#A file descriptor (FD) is a non-negative integer (e.g.,0for stdin,1for stdout,2for stderr) that Linux uses to track open files—a broad term including:Regular files (logs, configs)Network sockets (TCP/UDP connections)Pipes, FIFOs, and device files (e.g.,/dev/null).Daemons like Nginx, PostgreSQL, or Redis rely heavily on FDs to handle client connections, read/write data, and interact with the system. For example, a web server with 10,000 concurrent users may need 10,000 FDs (one per connection, plus logs and configs).Soft vs. Hard Limits#Linux enforces two types of FD limits per process:Soft Limit: The current, enforced limit. A process cantemporarilyincrease its soft limit up to the hard limit (e.g., viasetrlimit()).Hard Limit: The upper bound for the soft limit. Only the root user can adjust the hard limit (up to system-wide constraints).Think of the soft limit as a warning and the hard limit as a ceiling.Per-Process vs. System-Wide Limits#Per-Process Limits: Apply to individual processes (e.g., a single Nginx worker). Controlled byulimit(user-level) or process managers like systemd.System-Wide Limits: Apply to the entire system (e.g., total FDs across all processes). Controlled by kernel parameters (e.g.,fs.file-max).2. Checking Current Limits#To diagnose FD issues, first check the current limits for your user, a running daemon, or the system.For Your Shell Session#Useulimit(user limit) to check soft/hard limits for your interactive shell:# Check soft limit (default for new processes)ulimit -n # Check hard limitulimit -HnExample output:1024 # Soft limit (default on many systems) 4096 # Hard limitFor a Running Daemon#To check limits for a specific daemon (e.g., Nginx, PID1234), inspect its/procentry:# Replace 1234 with your daemons PID (find with pgrep nginx)cat /proc/1234/limits | grep Max open filesExample output:Max open files 1024 4096 filesHere,1024is the soft limit,4096the hard limit.System-Wide Limits#Check system-wide FD capacity withsysctl:# Total allowed FDs across all processessysctl fs.file-max # Maximum FD number a single process can open (per-process hard limit ceiling)sysctl fs.nr_openExample output:fs.file-max 9223372036854775807 # Default on modern kernels (theoretical max) fs.nr_open 1048576 # Typical default (1 million)3. Can You Really Set Unlimited? The Truth#The term unlimited is misleading. Linux does not allowtrulyunlimited FDs because:Kernel-Level Constraints#Even if you set a per-process limit to unlimited, the kernel enforces hard caps:fs.nr_open: The maximum FD number a single process can allocate (default:1048576on most systems). This prevents integer overflow in FD tracking.fs.file-max: The total number of FDs allowed system-wide (default: often set to(total RAM in KB)/10). Prevents耗尽内存 (OOM) from excessive FD allocation.Thus, unlimited inulimitor systemd translates to use the kernel’snr_openlimit. For example, iffs.nr_open1048576, settingLimitNOFILEinfinityin systemd will cap the process at1048576FDs.Why Unlimited Is Capped#If you try to setfs.nr_opento a value higher thanINT_MAX(2,147,483,647 on 32-bit systems), the kernel will reject it. On 64-bit systems,fs.nr_opencan be as high as2^64-1, but this is impractical—your system will run out of memory or CPU before hitting that limit.Key Takeaway: You can’t set FDs to unlimited, but you can set extremely high limits (e.g.,1048576or10000000) by adjusting per-process and kernel-level parameters.4. Adjusting Limits for Daemons: Step-by-Step#Daemons run in the background (often as root) and are started at boot, so temporary adjustments (e.g.,ulimitin a shell) won’t persist. Use these permanent methods instead.Temporary Adjustments (Not Recommended for Daemons)#For testing, you can increase limits in a shell before starting a process, but this won’t survive a reboot or service restart:# Increase soft limit to 8192 (must be ≤ hard limit)ulimit -Sn 8192 # Increase hard limit to 16384 (root only)sudo ulimit -Hn 16384 # Start your daemon in this shell (e.g., ./my-daemon)Permanent Adjustments withlimits.conf(PAM)#The/etc/security/limits.conffile sets limits for users/groups via PAM (Pluggable Authentication Modules).Note: This works for processes started by users (e.g.,sshsessions) but oftennotfor systemd daemons (which bypass PAM).Editlimits.confas root:sudo nano /etc/security/limits.confAdd lines for the daemon’s user (e.g.,nginx,postgres) or*for all users:# Format: domain type item valuenginx soft nofile 65536 # Soft limit for nginx usernginx hard nofile 1048576 # Hard limit (capped by fs.nr_open)domain: Username, group (prefixed with), or*(all).type:softorhard.item:nofile(number of open files).Caveat: For systemd-managed daemons,limits.confis often ignored. Use systemd’s native limit settings instead.Systemd Services:LimitNOFILE(Best for Modern Daemons)#Most modern Linux distributions use systemd to manage daemons. To set FD limits for a systemd service:Step 1: Override the Service File#Create an override file for your daemon (e.g., Nginx):sudo systemctl edit nginx.serviceStep 2: SetLimitNOFILE#Add the following under the[Service]section:[Service]LimitNOFILE1048576 # Sets soft and hard limit to 1,048,576 (capped by fs.nr_open)# Or use infinity to inherit fs.nr_open:# LimitNOFILEinfinityLimitNOFILEsoft:hard(e.g.,LimitNOFILE65536:1048576) lets you set separate soft/hard limits.infinityis equivalent tofs.nr_open(e.g.,1048576).Step 3: Reload and Restart#Apply the changes:sudo systemctl daemon-reload sudo systemctl restart nginxSystem-Wide Kernel Tuning (sysctl)#To increasefs.nr_open(per-process ceiling) orfs.file-max(system-wide total):Step 1: Editsysctl.conf#Create a custom sysctl file (e.g.,/etc/sysctl.d/99-fd-limits.conf):sudo nano /etc/sysctl.d/99-fd-limits.confStep 2: Set Kernel Parameters#Add:# Increase per-process max FD number (e.g., to 2 million)fs.nr_open2097152 # Increase system-wide total FDs (e.g., to 10 million)fs.file-max10000000Step 3: Apply Changes#sudo sysctl -p /etc/sysctl.d/99-fd-limits.conf5. Verifying the Changes#After adjustments, confirm limits are applied:For a Daemon (systemd)## Check Nginxs limits (replace with your daemons name)systemctl show nginx.service | grep LimitNOFILEExample output:LimitNOFILE1048576 LimitNOFILESoft1048576For a Process PID## Find the daemons PID (e.g., Nginx master process)pgrep nginx # Check its limitscat /proc/PID/limits | grep Max open filesExample output:Max open files 1048576 1048576 filesSystem-Wide#sysctl fs.nr_open fs.file-maxExample output:fs.nr_open 2097152 fs.file-max 100000006. Risks and Best Practices#Setting excessively high FD limits can harm stability. Follow these guidelines:Avoiding Resource Exhaustion#Don’t set limits blindly: A daemon with a bug (e.g., FD leaks) will consume more FDs until it hits the limit, crashing or causing OOM kills.Use just enough: Monitor your daemon’s FD usage (e.g.,lsof -p PID | wc -l) and set limits 20-30% higher than peak usage.Monitoring File Descriptors#Track FD usage with:lsof: List open files for a process (e.g.,lsof -p PID).ss: Count network sockets (e.g.,ss -sfor summary)./proc/sys/fs/file-nr: System-wide FD stats (e.g.,cat /proc/sys/fs/file-nrshowsallocated; free; max).Application-Specific Limits#Some daemons enforce their own FD limits (ignoring system limits):MySQL: Setopen_files_limitinmy.cnf(must be ≤ system limits).Redis: Usemaxclients(defaults to10000, but limited by FD limits).Nginx: Tuneworker_connections(must be ≤ per-worker FD limit).7. Conclusion#While you can’t set unlimited open files in Linux, you can configure extremely high limits by adjusting per-process (soft/hard) and system-wide (kernel) parameters. For modern daemons, systemd’sLimitNOFILEis the most reliable method, paired withsysctltuning for kernel constraints.Always prioritize monitoring and just-enough limits to avoid resource exhaustion. With careful tuning, your daemons will handle high loads without too many open files errors.8. References#Linux ulimit Man Pagesystemd.exec(5) — LimitNOFILE DocumentationKernel fs.nr_open and fs.file-max DocumentationPAM limits.conf Man PageNginx FD Tuning GuideMySQL open_files_limit Documentation