When the real-user-ID process count is at or above the soft RLIMIT_NPROC limit, these calls fail with EAGAIN:

This limit is not enforced for processes with CAP_SYS_ADMIN or CAP_SYS_RESOURCE capabilities.

RLIMIT_NPROC counts all processes with the same real user ID, system-wide — not just the children of the current process. This is why in the textbook example, setting the limit to 30 but having 26 pre-existing processes meant only 4 more could be created.

The limit is only checked in processes that have set it or inherited it. Another process owned by the same user that has RLIMIT_NPROC set to RLIM_INFINITY is not constrained.

Independently of RLIMIT_NPROC, Linux imposes a system-wide cap on the total number of threads (processes) across all users. This limit is in /proc/sys/kernel/threads-max (Linux 2.4+). Even root cannot exceed this. The default value is computed at boot based on available physical memory.

# View system-wide thread limit
$ cat /proc/sys/kernel/threads-max
62689

# Raise it (requires root)
# echo 100000 > /proc/sys/kernel/threads-max

There is no direct system call to query “how many processes does user X currently have?” The portable workaround on Linux is to scan /proc/PID/status files and look at the Uid field:

# The Uid line in /proc/PID/status format:
# Uid: real  effective  saved-set  filesystem
$ grep "^Uid:" /proc/*/status 2>/dev/null | awk '{print $2}' | sort | uniq -c
    # Shows count of processes per real UID

# Or: count processes for the current user
$ ps -u $(id -u) --no-headers | wc -l

#include 
#include 
#include 
#include 
#include <sys/resource.h>
#include <sys/wait.h>

int main(void)
{
    struct rlimit rl;
    pid_t pid;
    int children = 0;

    /* Set RLIMIT_NPROC: soft=5 extra processes, hard=10 */
    getrlimit(RLIMIT_NPROC, &rl);
    printf("Current NPROC: soft=%lld hard=%lld\n",
           (long long)rl.rlim_cur, (long long)rl.rlim_max);

    /* Lower soft to current_count + 3 so we can create only ~3 more */
    rl.rlim_cur = 10;   /* allow 10 total for this user */
    rl.rlim_max = 20;
    setrlimit(RLIMIT_NPROC, &rl);

    /* Fork in a loop until EAGAIN */
    while (1) {
        pid = fork();
        if (pid == -1) {
            if (errno == EAGAIN) {
                printf("fork() EAGAIN: RLIMIT_NPROC hit after %d children\n",
                       children);
                break;
            }
            perror("fork"); break;
        }
        if (pid == 0) {
            sleep(5);   /* Child: stay alive briefly */
            _exit(0);
        }
        children++;
        printf("  Created child %d (PID %d)\n", children, pid);
    }

    /* Clean up */
    while (wait(NULL) != -1) ;
    return 0;
}
/* Compile: gcc -o nproc_demo nproc_demo.c
   Note: actual number of children depends on pre-existing processes */