getrlimit(), setrlimit() - control maximum resource consumption
int getrlimit(int resource, struct rlimit *rlp);
int setrlimit(int resource, const struct rlimit *rlp);
Limits on the consumption of a variety of resources by the calling
process may be obtained with getrlimit() and set with setrlimit().
Each call to either getrlimit() or setrlimit() identifies a specific
resource to be operated upon as well as a resource limit. A resource
limit is represented by an rlimit 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 rlim_cur member specifies the current or soft limit and the
rlim_max 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 setrlimit() subject to
the constraints described above.
The value RLIM_INFINITY, defined in <sys/resource.h>, is considered to
be larger than any other limit value. If a call to getrlimit()
returns RLIM_INFINITY for a resource, it means the implementation does
not enforce limits on that resource. Specifying RLIM_INFINITY as any
resource limit value on a successful call to setrlimit() inhibits
enforcement of that resource limit.
The following resources are defined:
RLIMIT_CORE 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.
RLIMIT_CPU This is the maximum amount of CPU time
in seconds allowed for a UNIX 95
conforming application. If this limit
is exceeded, SIGXCPU is generated for
the application. The default action for
Hewlett-Packard Company - 1 - HP-UX Release 11i: November 2000
a UNIX 95 conforming application is to
kill the process and leave a core file.
If the process is blocking, catching or
ignoring SIGXCPU, the behavior is
unspecified. If the application is a
Classic HP-UX application, the kernel
will not send the signal as a result of
exceeding the CPU limit. However, if
this signal is sent explicitly to a
Classic HP-UX application by another
application or via the kill -XCPU
command, this signal will be delivered
and the default action will be taken.
In order for an application to be UNIX
95, it must be linked with unix95.o
either directly or indirectly. For
% cc /usr/lib/unix95.o prog.c
% export UNIX95=1
% cc prog.c
RLIMIT_DATA This is the maximum size of a process'
data segment in bytes. If this limit is
exceeded, the brk(), malloc(), and
sbrk() functions will fail with errno
set to ENOMEM.
RLIMIT_FSIZE This option is only applicable to UNIX
95 conforming applications. Please see
RLIMIT_CPU option above for explanation
on UNIX 95 conforming applications.
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, SIGXFSZ is generated for the
process. If the process is blocking,
catching or ignoring SIGXFSZ, continued
attempts to increase the size of a file
from end-of-file to beyond the limit
will fail with errno set to EFBIG.
RLIMIT_NOFILE This is a number one greater than the
maximum value that the system may assign
to a newly-created descriptor. If this
Hewlett-Packard Company - 2 - HP-UX Release 11i: November 2000
limit is exceeded, functions that
allocate new file descriptors may fail
with errno set to EMFILE. This limit
constrains the number of file
descriptors that a process may allocate.
RLIMIT_STACK 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,
SIGSEGV is generated for the process.
If the process is blocking or ignoring
SIGSEGV, or is catching SIGSEGV and has
not made arrangements to use an
alternate stack, the disposition of
SIGSEGV will be set to SIG_DFL before it
RLIMIT_AS This is the maximum size of a process'
total available memory, in bytes. If
this limit is exceeded, the brk(),
malloc(), mmap(), and sbrk() functions
will fail with errno set to ENOMEM. In
addition, the automatic stack growth
will fail with the effects outlined
RLIMIT_AIO_OPS This is the maximum number of POSIX
Asynchronous I/O operations that a
process can have enqueued
simultaneously. If this limit is
exceeded, the aio_read(), aio_write(),
and lio_listio() functions will fail
with errno set to EAGAIN.
RLIMIT_AIO_MEM This is the maximum number of bytes of
memory that can be locked simultaneously
by POSIX Asynchronous I/O requests from
a single process.
Upon successful completion, getrlimit() and setrlimit() return 0.
Otherwise, these functions return -1 and set errno to indicate the
The getrlimit() and setrlimit() functions will fail if:
[EINVAL] An invalid resource was specified; or in a
setrlimit() call, the new rlim_cur exceeds the new
Hewlett-Packard Company - 3 - HP-UX Release 11i: November 2000
[EFAULT] The address specified for rlp is invalid.
Reliable detection of this error is implementation
[EPERM] The limit specified to setrlimit() would have
raised the maximum limit value, and the calling
process does not have appropriate privileges.
The setrlimit() function may fail if:
[EINVAL] The limit specified cannot be lowered because
current usage is already higher than the limit.
[EPERM] 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.
[EINVAL] 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.
[EINVAL] The value of rlp->rlim_cur is less than the number
of file descriptors the process already has
[EINVAL] The value of rlp->rlim_max is less than the
current soft limit.
The maximum size of a file returned by getrlimit() is in terms of
bytes. The maximum size of a file returned by ulimit (see ulimit(2))
with UL_GETFSIZE is in terms of blocks of size 512 bytes. The value
returned by ulimit with UL_GETFSIZE may thus have to be rounded down
to a multiple of 512.
getrlimit() and setrlimit() were developed by HP, AT&T, and the
University of California, Berkeley.
brk(2), exec(2), fork(2), creat64(2), malloc(3C), open(2),
sigaltstack(2), sysconf(2), ulimit(2), <stropts.h>, <sys/resource.h>.
First released in Issue 4, Version 2.
Hewlett-Packard Company - 4 - HP-UX Release 11i: November 2000