How To Check Ulimit In Linux

Checking your ulimit settings in Linux helps you understand the resource limits applied to your user account. If you have ever run into errors like “too many open files” or “cannot allocate memory,” you probably need to check your ulimit. This guide will show you exactly how to check ulimit in linux, step by step, with clear commands and examples.

Resource limits control how much CPU time, memory, and file handles your processes can use. Without knowing these limits, you might hit unexpected barriers. Let us start with the basics and then move into advanced checks.

What Is Ulimit In Linux

Ulimit is a built-in shell command that sets or displays user-level resource limits. It is part of the PAM (Pluggable Authentication Modules) system and the Linux kernel. Each user and process has soft and hard limits for resources like open files, stack size, and max user processes.

Soft limits are the current working limit. Hard limits are the maximum a user can set without root privileges. When you check ulimit, you see both values.

Now we get to the main topic. The most direct way to check ulimit is by running the ulimit command in your terminal. Open a terminal window and type:

ulimit -a

This shows all current resource limits for your shell session. You will see output similar to this:

core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 7841
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 7841
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

Each line shows a resource type, its current value, and the flag you use to check it individually. For example, to check just the max number of open files, run:

ulimit -n

This returns a single number, like 1024. That is the soft limit for open files in your current shell.

Check Soft And Hard Limits Separately

You can view soft and hard limits individually using the -S and -H flags. For soft limits, type:

ulimit -Sa

For hard limits, type:

ulimit -Ha

These commands show all limits with their respective type. If you want a specific resource, combine the flags. For example, to see the hard limit for open files:

ulimit -Hn

Understanding the difference is crucial. A soft limit can be increased up to the hard limit. The hard limit can only be raised by root.

Check Ulimit For A Different User

Sometimes you need to check limits for another user account. You cannot run ulimit directly for another user because it is a shell built-in. Instead, use the su or sudo command to switch users first. For example:

sudo -u username ulimit -a

Or switch to that user:

su - username
ulimit -a

This shows the limits applied when that user logs in. Note that limits may vary based on the user’s shell configuration files like .bashrc or .profile.

Check Ulimit For A Running Process

If a process is already running, you can check its actual resource limits by reading the /proc filesystem. Find the process ID (PID) first using ps or top. Then run:

cat /proc/PID/limits

Replace PID with the actual number. This shows the soft and hard limits for that specific process. It is useful when debugging why a process is failing.

Common Ulimit Checks And Their Meanings

Here are the most frequently checked limits and what they control:

open files (-n): Maximum number of file descriptors a process can open. Common default is 1024.
max user processes (-u): Maximum number of processes a user can create. Often set to 7841 or similar.
stack size (-s): Maximum stack size in kilobytes. Default is often 8192 KB.
core file size (-c): Maximum size of core dump files. Zero means no core dumps.
max memory size (-m): Maximum resident set size. Often unlimited.
cpu time (-t): Maximum CPU time in seconds. Unlimited by default.

Knowing these values helps you tune your system for applications like databases, web servers, or custom scripts.

Check Ulimit Permanently Vs Temporarily

The ulimit command only affects the current shell session. To make changes permanent, you edit configuration files. The main files are:

/etc/security/limits.conf – System-wide limits for PAM.
/etc/security/limits.d/ – Directory for custom limit files.
/etc/systemd/system.conf and /etc/systemd/user.conf – For systemd services.

To check the permanent limits set in limits.conf, you can view the file:

cat /etc/security/limits.conf

Lines starting with # are comments. Active lines look like:

username soft nofile 4096
username hard nofile 8192

This sets the soft limit for open files to 4096 and hard limit to 8192 for user username.

Check Ulimit For Systemd Services

If you run services under systemd, their limits are set in service unit files. Check a service’s limits with:

systemctl show service-name | grep -i limit

Replace service-name with the actual service, like nginx. This shows all limit-related parameters. For example:

LimitNOFILE=4096
LimitNPROC=100

You can also check the current limits of a running systemd service by looking at its cgroup:

cat /sys/fs/cgroup/system.slice/service-name.service/pids.max

But the systemctl show method is simpler.

Why Check Ulimit Regularly

Regularly checking ulimit helps prevent resource exhaustion. Applications like Elasticsearch, MongoDB, or Apache often require higher limits. If you skip this check, you might see mysterious crashes or performance drops.

For example, a web server handling many connections may hit the open files limit. Checking ulimit tells you the current cap so you can adjust it.

Also, when you install new software, the installer might set limits. Verifying them ensures they are applied correctly.

Common Errors From Low Limits

Here are typical errors you see when limits are too low:

“Too many open files” – The open files limit is reached.
“Cannot fork” – The max user processes limit is hit.
“Resource temporarily unavailable” – Similar to fork failure.
“Stack size too small” – Stack limit is too low for the application.

Checking ulimit helps you diagnose these quickly.

How To Interpret Ulimit Output

The output from ulimit -a uses units like blocks, kbytes, and number. Here is a quick reference:

blocks: Usually 512 bytes per block for core and file sizes.
kbytes: Kilobytes for memory-related limits.
seconds: CPU time.
number: Count for open files, processes, signals.

If a value shows “unlimited,” it means no limit is set for that resource. However, the kernel still has its own limits, so “unlimited” is not truly infinite.

Check Ulimit In Different Shells

The ulimit command works in bash, zsh, and most POSIX shells. But syntax may vary slightly. In bash, the flags are consistent. In sh or dash, the same flags apply. In csh or tcsh, use limit instead:

limit

This shows limits in a different format. For example:

cputime         unlimited
filesize        unlimited
datasize        unlimited
stacksize       8 MB
coredumpsize    0 kB
memoryuse       unlimited
maxproc         7841
descriptors     1024

If you are writing scripts, stick with bash for portability.

Step-By-Step Guide To Check Ulimit

Let me walk you through a complete check from start to finish.

Open a terminal.
Run ulimit -a to see all limits.
Note the open files limit (-n).
Check hard limits with ulimit -Ha.
If you need to check for another user, use sudo -u username ulimit -a.
For a running process, find its PID with ps aux | grep processname.
Then run cat /proc/PID/limits.
To see system-wide limits, check /etc/security/limits.conf.
For systemd services, use systemctl show servicename | grep -i limit.

That covers all major methods.

Check Ulimit With A Script

You can automate the check with a simple bash script. Here is an example:

#!/bin/bash
echo "Current ulimit settings for $USER:"
ulimit -a
echo ""
echo "Hard limits:"
ulimit -Ha

Save this as check_ulimit.sh, make it executable with chmod +x check_ulimit.sh, and run it. This is useful for system monitoring.

Troubleshooting Ulimit Checks

Sometimes you run into issues when checking ulimit. Here are common problems and fixes:

Command not found: Ulimit is a shell built-in, so it should always be available. If you get an error, you might be in a non-POSIX shell like fish. Use bash -c 'ulimit -a' instead.
Permission denied: Checking another user’s limits with sudo requires proper privileges. Use sudo -u username or switch users.
No output for /proc/PID/limits: The process may have exited or you do not have permission. Run as root or check the PID again.
Limits not matching configuration: Changes to limits.conf require a new login session. Log out and back in, or restart the service.

These tips should resolve most hiccups.

Check Ulimit On Different Linux Distributions

The ulimit command works the same across distributions like Ubuntu, CentOS, Fedora, and Debian. However, default limits may vary. For example, Ubuntu often sets open files to 1024, while CentOS may use 4096 for some users.

Systemd-based distributions (most modern ones) also have service-level limits. Always check both the user shell limits and the service limits for applications.

Frequently Asked Questions

How do I check the ulimit for open files in Linux?

Run ulimit -n to see the soft limit for open files. For the hard limit, use ulimit -Hn. You can also check all limits with ulimit -a.

What is the difference between soft and hard ulimit?

Soft limits are the current working limits that can be increased up to the hard limit. Hard limits are the maximum values set by the system administrator. Only root can raise hard limits.

Can I check ulimit for a specific process?

Yes, find the process ID (PID) and read /proc/PID/limits. This shows both soft and hard limits for that running process.

How do I check ulimit permanently set in the system?

View the file /etc/security/limits.conf and any files in /etc/security/limits.d/. For systemd services, use systemctl show servicename | grep -i limit.

Why does my ulimit show unlimited for some resources?

Unlimited means no explicit limit is set. However, the kernel still has inherent limits. For example, memory is ultimately bounded by physical RAM and swap.

Best Practices For Ulimit Management

After you learn how to check ulimit in linux, you should also manage it wisely. Here are some tips:

Always check limits before deploying a new application.
Set limits in /etc/security/limits.conf for persistent changes.
For systemd services, use LimitNOFILE and similar directives in unit files.
Monitor limits with scripts or tools like prometheus.
Document your limit settings for team reference.

By following these practices, you avoid resource-related outages.

Final Thoughts On Checking Ulimit

Knowing how to check ulimit in linux is a fundamental skill for any system administrator or developer. It helps you understand the boundaries your processes operate within. With the commands and methods covered here, you can quickly diagnose and resolve limit-related issues.

Remember to check both soft and hard limits, and verify them for different users and processes. Regular checks keep your system running smoothly. If you ever hit a limit, now you know exactly how to find it and what to do next.