getrlimit(2) System Calls Manual getrlimit(2)
NAME
getrlimit(), setrlimit() - control maximum resource consumption
SYNOPSIS
DESCRIPTION
Limits on the consumption of a variety of resources by the calling process may be obtained with and set with Each call to either or identi-
fies a specific resource to be operated upon as well as a resource limit. A resource limit is represented by an structure, pointed to by
the rlp argument and includes the following members:
rlim_t rlim_cur; /* Current (soft) limit */
rlim_t rlim_max; /* Hard limit */
The member specifies the current or soft limit and the member specifies the maximum or hard limit. Soft limits may be changed by a process
to any value that is less than or equal to the hard limit. A process may (irreversibly) lower its hard limit to any value that is greater
than or equal to the soft limit. Only a process with appropriate privileges can raise a hard limit. Both hard and soft limits can be
changed in a single call to subject to the constraints described above.
The value defined in is considered to be larger than any other limit value. If a call to returns for a resource, it means the implementa-
tion does not enforce limits on that resource. Specifying as any resource limit value on a successful call to inhibits enforcement of that
resource limit.
The following resources are defined:
This is the maximum size of a core file in bytes that may
be created by a process. A limit of 0 will prevent the creation of a core file. If this limit is exceeded, the
writing of a core file will terminate at this size.
This is the maximum amount of CPU time in seconds used
by a process. If this limit is exceeded, is generated for the process. The default action is to kill the process
and leave a core file.
This is the maximum size of a process data segment in bytes.
If this limit is exceeded, the and functions will fail with set to ENOMEM. The upper limit is enforced through the
tunable However setting to will delay the upper limit enforcement until the resource is allocated for the applica-
tion.
This is the maximum size of a file in bytes that may be created
by a process. A limit of 0 will prevent the creation of a file. If a write or truncate operation would cause this
limit to be exceeded, is generated for the process. If the process is blocking, catching or ignoring continued
attempts to increase the size of a file from end-of-file to beyond the limit will fail with set to
This is a number one greater than the maximum value that the system
may assign to a newly-created descriptor. If this limit is exceeded, functions that allocate new file descriptors
may fail with set to This limit constrains the number of file descriptors that a process may allocate.
This is the maximum size of a process stack in bytes.
The implementation will not automatically grow the stack beyond this limit. If this limit is exceeded, is generated
for the process. If the process is blocking or ignoring or is catching and has not made arrangements to use an
alternate stack, the disposition of will be set to before it is generated. The upper limit is enforced through the
tunable However setting to will delay the upper limit enforcement until the resource is allocated for the applica-
tion.
This is the maximum size of a process's total available memory,
in bytes. If this limit is exceeded, the and functions will fail with set to In addition, the automatic stack growth
will fail with the effects outlined above.
This is the maximum number of POSIX Asynchronous I/O operations
that a process can have enqueued simultaneously. If this limit is exceeded, the and functions will fail with set to
This is the maximum number of bytes of memory that can be locked
simultaneously by POSIX Asynchronous I/O requests from a single process.
Security Restrictions
Raising hard limits with the call requires the privilege (PRIV_LIMIT). Processes owned by the superuser have this privilege. Processes
owned by other users may have this privilege, depending on system configuration.
See privileges(5) for more information about privileged access on systems that support fine-grained privileges.
RETURN VALUE
Upon successful completion, and return 0. Otherwise, these functions return -1 and set to indicate the error.
ERRORS
The and functions will fail if:
The address specified for
rlp is invalid. Reliable detection of this error is implementation dependent.
An invalid resource was specified; or in a
call, the new rlim_cur exceeds the new rlim_max.
The limit specified to
would have raised the maximum limit value, and the calling process does not have appropriate privileges.
The function may fail if:
The limit specified cannot be lowered because current usage is
already higher than the limit.
A user with appropriate privileges has attempted to raise
rlp->rlim_cur or rlp->rlim_max to a value greater than the system is capable of supporting.
The value of rlp->rlim_cur is less than the number of file descriptors the process already has allocated.
The value of rlp->rlim_max is less than the current soft limit.
The rlp argument specified a hard or soft limit higher than the current hard limit value, and the caller does not have
the appropriate privileges.
WARNINGS
The maximum size of a file returned by is in terms of bytes. The maximum size of a file returned by (see ulimit(2)) with is in terms of
blocks of size 512 bytes. The value returned by with may thus have to be rounded down to a multiple of 512.
The total address space used by a process depends on the platform it is run on. When porting applications, limits set by with may need to
be adjusted. For example, programs tend to use more memory on systems than on PA-RISC systems.
AUTHOR
and were developed by HP, AT&T, and the University of California, Berkeley.
SEE ALSO
brk(2), creat64(2), exec(2), fork(2), open(2), sigaltstack(2), sysconf(2), ulimit(2), malloc(3C), maxdsiz(5), maxssiz(5).
getrlimit(2)