How to Restrict Memory Usage in Linux: A Practical Guide

Restricting memory usage in Linux allows system administrators and users to control how much RAM a process or group of processes can consume. This is critical for maintaining system stability, preventing runaway applications from exhausting resources, and optimizing performance on servers or multi-user systems. By setting memory limits, you can avoid system slowdowns, crashes, or unexpected behavior caused by excessive memory consumption.

What You’ll Need

• A Linux system with root or sudo privileges
• Basic familiarity with the Linux command line
• Access to system configuration files or ability to install packages if needed

Step-by-Step

1. Check current memory usage and limits: Before making changes, understand your system’s current memory consumption. Use free -h to view overall usage and top or htop to monitor process-level memory.
2. Use ulimit to set per-user memory limits: The ulimit command controls resource limits for shell sessions and processes started from them. To restrict virtual memory size (address space), run:

   ulimit -v <kilobytes>

   For example, ulimit -v 1048576 limits processes to 1 GB of virtual memory. Add this command to ~/.bashrc or relevant shell config files to make it persistent per user.

3. Configure cgroups (Control Groups) for fine-grained control: cgroups allow you to limit resources like memory for specific processes or groups. Most modern Linux distributions support cgroups v1 or v2.
   • Create a cgroup directory:

     sudo mkdir /sys/fs/cgroup/memory/mygroup

   • Set memory limit (in bytes):

     echo 500M | sudo tee /sys/fs/cgroup/memory/mygroup/memory.limit_in_bytes

   • Add your process PID to the cgroup:

     echo <PID> | sudo tee /sys/fs/cgroup/memory/mygroup/cgroup.procs

   This confines the process to 500 MB of RAM.

4. Use systemd resource control for managed services: If your process runs as a systemd service, you can limit memory via the service unit file.
   • Edit the service file, e.g., /etc/systemd/system/myservice.service.
   • Add or modify the [Service] section:

     MemoryMax=500M
     

   • Reload systemd and restart the service:

     sudo systemctl daemon-reload
     sudo systemctl restart myservice
     

   This limits the service’s memory usage to 500 MB.

5. Limit memory for Docker containers (if applicable): When running containers, use Docker’s memory flags:

   docker run --memory=500m your-image

   This restricts the container’s memory usage to 500 MB.

6. Verify limits are active: Use cat /sys/fs/cgroup/memory/mygroup/memory.limit_in_bytes or systemctl show myservice -p MemoryMax to confirm limits. Monitor processes to ensure they do not exceed set boundaries.
7. Adjust swap usage if needed: Limiting memory might cause swapping. Check swap usage with swapon --show and adjust the swappiness parameter if necessary:

   sudo sysctl vm.swappiness=10

   Lower values reduce swap usage, helping performance when memory limits are tight.

8. Automate limits for multiple users or processes: For multiple users, configure limits in /etc/security/limits.conf or PAM limits modules. For groups of processes, create cgroup hierarchies to manage them collectively.

Common Mistakes

• Setting limits too low: Overly restrictive memory limits can cause legitimate processes to fail or crash, leading to system instability.
• Forgetting to reload or restart services: Changes to systemd unit files or cgroup configurations often require a daemon reload or service restart to take effect.
• Confusing virtual memory with physical RAM: The ulimit -v option limits virtual address space, which is not the same as actual RAM usage.
• Ignoring swap effects: When memory limits are reached, processes may start swapping heavily, degrading performance.
• Not applying limits to the correct process: Adding the wrong PID to a cgroup or misconfiguring service files won’t restrict the intended target.

Tips

• Use monitoring tools like htop, ps, and cgroupfs to track memory usage in real time.
• Test limits on non-production environments first to avoid disrupting critical services.
• Combine memory limits with CPU and I/O controls in cgroups to better manage overall resource usage.
• Create scripts to automate cgroup creation and assignment for recurring tasks or batch jobs.
• Use systemd slices and scopes for hierarchical resource management if you manage many services.
• Regularly review and adjust limits based on observed workload and system behavior.

Troubleshooting

If memory restrictions do not seem to apply or processes exceed limits, consider the following:

• Check permissions: Ensure you have sufficient privileges to create and modify cgroups or edit systemd service files.
• Confirm cgroup version: Some commands and paths differ between cgroups v1 and v2. Use mount | grep cgroup to verify your system’s cgroup version.
• Verify process assignment: Confirm the target process’s PID is correctly added to the desired cgroup.
• Look for conflicting limits: User-level ulimit settings, PAM limits, and systemd resource controls can overlap. Ensure they are consistent.
• Review logs: Check journalctl or system logs for messages about OOM (Out of Memory) kills or cgroup errors.
• Restart services or reboot: Some changes require a systemd daemon reload or full reboot to take effect properly.
• Swap and memory pressure: If the system swaps excessively, consider increasing RAM or adjusting swappiness.

Frequently Asked Questions

How do I limit memory for a single process?

You can use cgroups by creating a memory-limited group and adding the process PID to it, or launch the process via systemd with a MemoryMax setting.

What’s the difference between ulimit and cgroups?

ulimit sets per-shell or per-user resource limits, often simpler but less flexible. cgroups provide fine-grained, hierarchical control over multiple resource types for processes or groups.

Can I restrict memory usage for all users?

Yes, by configuring PAM limits in /etc/security/limits.conf or using system-wide cgroups and systemd slices to enforce limits globally.

What happens when a process hits its memory limit?

The process may be terminated by the kernel’s OOM killer or receive an allocation error, depending on the limit type and enforcement method.

Is it possible to limit swap usage separately?

Linux does not directly limit swap per process, but you can adjust system-wide swappiness or isolate processes using cgroups with swap accounting enabled.

Do memory limits affect performance?

Yes, if limits are too tight, processes may fail or swap heavily, degrading performance. Proper tuning balances resource usage and system stability.

By following these steps and best practices, you can effectively manage and restrict memory usage on your Linux system, improving reliability and resource distribution across applications and users.

Related

• How to Fix a Torn Sling Bag Strap: Easy Step-by-Step Repair Guide
• How to Sew a Sling Bag Without a Sewing Machine Step-by-Step
• How to Sew a Small Sling Bag: Easy Step-by-Step Guide