Originální popis anglicky:
getrlimit, getrusage, setrlimit - get/set resource limits and usage
Návod, kniha: Linux Programmer's Manual
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
int getrlimit(int resource, struct rlimit
*rlim);
int getrusage(int who, struct rusage *usage);
int setrlimit(int resource, const struct rlimit
*rlim);
getrlimit and
setrlimit get and set resource limits respectively.
Each resource has an associated soft and hard limit, as defined by the
rlimit structure (the
rlim argument to both
getrlimit()
and
setrlimit()):
struct rlimit {
rlim_t rlim_cur; /* Soft limit */
rlim_t rlim_max; /* Hard limit (ceiling
for rlim_cur) */
};
The soft limit is the value that the kernel enforces for the corresponding
resource. The hard limit acts as a ceiling for the soft limit: an unprivileged
process may only set its soft limit to a value in the range from 0 up to the
hard limit, and (irreversibly) lower its hard limit. A privileged process
(under Linux: one with the
CAP_SYS_RESOURCE capability) may make
arbitrary changes to either limit value.
The value
RLIM_INFINITY denotes no limit on a resource (both in the
structure returned by
getrlimit() and in the structure passed to
setrlimit()).
resource must be one of:
- RLIMIT_AS
- The maximum size of the process's virtual memory (address
space) in bytes. This limit affects calls to brk(2), mmap(2)
and mremap(2), which fail with the error ENOMEM upon
exceeding this limit. Also automatic stack expansion will fail (and
generate a SIGSEGV that kills the process when no alternate stack has been
made available). Since the value is a long, on machines with a 32-bit long
either this limit is at most 2 GiB, or this resource is unlimited.
- RLIMIT_CORE
- Maximum size of core file. When 0 no core dump files
are created. When nonzero, larger dumps are truncated to this size.
- RLIMIT_CPU
- CPU time limit in seconds. When the process reaches the
soft limit, it is sent a SIGXCPU signal. The default action for
this signal is to terminate the process. However, the signal can be
caught, and the handler can return control to the main program. If the
process continues to consume CPU time, it will be sent SIGXCPU once
per second until the hard limit is reached, at which time it is sent
SIGKILL. (This latter point describes Linux 2.2 and 2.4 behaviour.
Implementations vary in how they treat processes which continue to consume
CPU time after reaching the soft limit. Portable applications that need to
catch this signal should perform an orderly termination upon first receipt
of SIGXCPU.)
- RLIMIT_DATA
- The maximum size of the process's data segment (initialized
data, uninitialized data, and heap). This limit affects calls to
brk() and sbrk(), which fail with the error ENOMEM
upon encountering the soft limit of this resource.
- RLIMIT_FSIZE
- The maximum size of files that the process may create.
Attempts to extend a file beyond this limit result in delivery of a
SIGXFSZ signal. By default, this signal terminates a process, but a
process can catch this signal instead, in which case the relevant system
call (e.g., write(), truncate()) fails with the error
EFBIG.
- RLIMIT_LOCKS
- A limit on the combined number of flock() locks and
fcntl() leases that this process may establish. (Early Linux 2.4
only.)
- RLIMIT_MEMLOCK
- The maximum number of bytes of virtual memory that may be
locked into RAM using mlock() and mlockall().
- RLIMIT_NOFILE
- Specifies a value one greater than the maximum file
descriptor number that can be opened by this process. Attempts
(open(), pipe(), dup(), etc.) to exceed this limit
yield the error EMFILE.
- RLIMIT_NPROC
- The maximum number of processes that can be created for the
real user ID of the calling process. Upon encountering this limit,
fork() fails with the error EAGAIN.
- RLIMIT_RSS
- Specifies the limit (in pages) of the process's resident
set (the number of virtual pages resident in RAM). This limit only has
effect in Linux 2.4 onwatrds, and there only affects calls to
madvise() specifying MADVISE_WILLNEED.
- RLIMIT_STACK
- The maximum size of the process stack, in bytes. Upon
reaching this limit, a SIGSEGV signal is generated. To handle this
signal, a process must employ an alternate signal stack
(sigaltstack(2)).
RLIMIT_OFILE is the BSD name for
RLIMIT_NOFILE.
getrusage returns the current resource usages, for a
who of either
RUSAGE_SELF or
RUSAGE_CHILDREN. The former asks for resources
used by the current process, the latter for resources used by those of its
children that have terminated and have been waited for.
struct rusage {
struct timeval ru_utime; /* user time used */
struct timeval ru_stime; /* system time used */
long ru_maxrss; /* maximum resident set size */
long ru_ixrss; /* integral shared memory size */
long ru_idrss; /* integral unshared data size */
long ru_isrss; /* integral unshared stack size */
long ru_minflt; /* page reclaims */
long ru_majflt; /* page faults */
long ru_nswap; /* swaps */
long ru_inblock; /* block input operations */
long ru_oublock; /* block output operations */
long ru_msgsnd; /* messages sent */
long ru_msgrcv; /* messages received */
long ru_nsignals; /* signals received */
long ru_nvcsw; /* voluntary context switches */
long ru_nivcsw; /* involuntary context switches */
};
On success, zero is returned. On error, -1 is returned, and
errno is set
appropriately.
- EFAULT
- rlim or usage points outside the accessible
address space.
- EINVAL
- getrlimit or setrlimit is called with a bad
resource, or getrusage is called with a bad who.
- EPERM
- An unprivileged process tried to use setrlimit() to
increase a soft or hard limit above the current hard limit; the
CAP_SYS_RESOURCE capability is required to do this. Or, the process
tried to use setrlimit() to increase the soft or hard RLIMIT_NOFILE
limit above the current kernel maximum (NR_OPEN).
SVr4, BSD 4.3
Including
<sys/time.h> is not required these days, but increases
portability. (Indeed,
struct timeval is defined in
<sys/time.h>.)
On Linux, if the disposition of
SIGCHLD is set to
SIG_IGN then the
resource usages of child processes are automatically included in the value
returned by
RUSAGE_CHILDREN, although POSIX 1003.1-2001 explicitly
prohibits this.
The above struct was taken from BSD 4.3 Reno. Not all fields are meaningful
under Linux. Right now (Linux 2.4, 2.6) only the fields
ru_utime,
ru_stime,
ru_minflt,
ru_majflt, and
ru_nswap are
maintained.
dup(2),
fcntl(2),
fork(2),
mlock(2),
mlockall(2),
mmap(2),
open(2),
quotactl(2),
sbrk(2),
wait3(2),
wait4(2),
malloc(3),
ulimit(3),
capabilities(7),
signal(7)
