getrlimit(2)getrlimit(2)NAMEgetrlimit(), setrlimit() - control maximum resource consumption
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 iden‐
tifies 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 pre‐
vent the creation of a core file. If this limit
is exceeded, the writing of a core file will ter‐
minate at this size.
This is the maximum amount of CPU time in seconds used
by a process. If this limit is exceeded, is gen‐
erated 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 application.
This is the maximum size of a file in bytes that may be created
by a process. A limit of 0 will prevent the cre‐
ation of a file. If a write or truncate opera‐
tion 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 application.
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
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.
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 configura‐
See privileges(5) for more information about privileged access on sys‐
tems that support fine-grained privileges.
Upon successful completion, and return 0. Otherwise, these functions
return −1 and set to indicate the error.
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
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
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.
The maximum size of a file returned by is in terms of bytes. The maxi‐
mum 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.
and were developed by HP, AT&T, and the University of California,
SEE ALSObrk(2), creat64(2), exec(2), fork(2), open(2), sigaltstack(2),
sysconf(2), ulimit(2), malloc(3C), maxdsiz(5), maxssiz(5).