What do you know about ulimits in Linux systems…

ulimits (user limits) in Linux is a kernel mechanism that allows setting restrictions on the consumption of system resources for users, groups, or processes. They help prevent resource exhaustion by a single process, which could lead to system instability or failure.

Main categories of restrictions:

Number of processes: The maximum number of child processes that a user or process can create.
File size: The maximum size of a file that a user or process can create.
Number of open files: The maximum number of file descriptors a process can open.
Stack size: The maximum stack size for processes.
Memory usage: Restrictions on virtual memory (resident set size, data segment size, and others).
Scheduling priority: The maximum priority with which a process can operate.
File locks: The number of file locks.

Management of ulimits is carried out through:

The ulimit command (built into the shell): Allows viewing and setting limits for the current shell and its child processes.

# View all current limits (soft and hard)
ulimit -a

# View the limit on the number of open files (soft)
ulimit -n

# Set soft limit on the number of open files to 4096
ulimit -n 4096

# Set hard limit on the number of open files to 8192 (only for root or if soft limit is lower)
ulimit -Hn 8192

The /etc/security/limits.conf file: Allows setting permanent limits for specific users, groups, or all users (*) at the system level. Changes take effect after the next user login.

# Syntax: <domain> <type> <item> <value>

# domain: user (@group, *)
# type: soft | hard
# item: core, nproc, nofile, virtualmem, etc.
# value: limit value

# Limit for user 'devops' on the number of open files (soft=4096, hard=8192)
devops soft nofile 4096
devops hard nofile 8192

# Limit for group 'developers' on the number of processes (hard=1000)
@developers hard nproc 1000

# Limit on file size for all users (hard=unlimited)
* hard fsize unlimited

System calls (e.g., setrlimit, getrlimit): Programs can programmatically set or get their own limits during execution. Processes without privileges can only decrease their hard limits or change soft limits up to the value of the hard limit. Root can set any limits.

Understanding ulimits is critical for debugging resource issues (e.g., "too many open files"), preventing DoS attacks at the resource level, and tuning application performance. It is especially important when running services, containers, or databases.

What do you know about ulimits in Linux systems?