mirror of https://github.com/mkerrisk/man-pages
803 lines
23 KiB
Groff
803 lines
23 KiB
Groff
.\" Copyright (c) 1992 Drew Eckhardt, March 28, 1992
|
|
.\" and Copyright (c) 2002, 2004, 2005, 2008, 2010 Michael Kerrisk
|
|
.\"
|
|
.\" %%%LICENSE_START(VERBATIM)
|
|
.\" Permission is granted to make and distribute verbatim copies of this
|
|
.\" manual provided the copyright notice and this permission notice are
|
|
.\" preserved on all copies.
|
|
.\"
|
|
.\" Permission is granted to copy and distribute modified versions of this
|
|
.\" manual under the conditions for verbatim copying, provided that the
|
|
.\" entire resulting derived work is distributed under the terms of a
|
|
.\" permission notice identical to this one.
|
|
.\"
|
|
.\" Since the Linux kernel and libraries are constantly changing, this
|
|
.\" manual page may be incorrect or out-of-date. The author(s) assume no
|
|
.\" responsibility for errors or omissions, or for damages resulting from
|
|
.\" the use of the information contained herein. The author(s) may not
|
|
.\" have taken the same level of care in the production of this manual,
|
|
.\" which is licensed free of charge, as they might when working
|
|
.\" professionally.
|
|
.\"
|
|
.\" Formatted or processed versions of this manual, if unaccompanied by
|
|
.\" the source, must acknowledge the copyright and authors of this work.
|
|
.\" %%%LICENSE_END
|
|
.\"
|
|
.\" Modified by Michael Haardt <michael@moria.de>
|
|
.\" Modified 1993-07-23 by Rik Faith <faith@cs.unc.edu>
|
|
.\" Modified 1996-01-13 by Arnt Gulbrandsen <agulbra@troll.no>
|
|
.\" Modified 1996-01-22 by aeb, following a remark by
|
|
.\" Tigran Aivazian <tigran@sco.com>
|
|
.\" Modified 1996-04-14 by aeb, following a remark by
|
|
.\" Robert Bihlmeyer <robbe@orcus.ping.at>
|
|
.\" Modified 1996-10-22 by Eric S. Raymond <esr@thyrsus.com>
|
|
.\" Modified 2001-05-04 by aeb, following a remark by
|
|
.\" Håvard Lygre <hklygre@online.no>
|
|
.\" Modified 2001-04-17 by Michael Kerrisk <mtk.manpages@gmail.com>
|
|
.\" Modified 2002-06-13 by Michael Kerrisk <mtk.manpages@gmail.com>
|
|
.\" Added note on nonstandard behavior when SIGCHLD is ignored.
|
|
.\" Modified 2002-07-09 by Michael Kerrisk <mtk.manpages@gmail.com>
|
|
.\" Enhanced descriptions of 'resource' values
|
|
.\" Modified 2003-11-28 by aeb, added RLIMIT_CORE
|
|
.\" Modified 2004-03-26 by aeb, added RLIMIT_AS
|
|
.\" Modified 2004-06-16 by Michael Kerrisk <mtk.manpages@gmail.com>
|
|
.\" Added notes on CAP_SYS_RESOURCE
|
|
.\"
|
|
.\" 2004-11-16 -- mtk: the getrlimit.2 page, which formally included
|
|
.\" coverage of getrusage(2), has been split, so that the latter
|
|
.\" is now covered in its own getrusage.2.
|
|
.\"
|
|
.\" Modified 2004-11-16, mtk: A few other minor changes
|
|
.\" Modified 2004-11-23, mtk
|
|
.\" Added notes on RLIMIT_MEMLOCK, RLIMIT_NPROC, and RLIMIT_RSS
|
|
.\" to "CONFORMING TO"
|
|
.\" Modified 2004-11-25, mtk
|
|
.\" Rewrote discussion on RLIMIT_MEMLOCK to incorporate kernel
|
|
.\" 2.6.9 changes.
|
|
.\" Added note on RLIMIT_CPU error in older kernels
|
|
.\" 2004-11-03, mtk, Added RLIMIT_SIGPENDING
|
|
.\" 2005-07-13, mtk, documented RLIMIT_MSGQUEUE limit.
|
|
.\" 2005-07-28, mtk, Added descriptions of RLIMIT_NICE and RLIMIT_RTPRIO
|
|
.\" 2008-05-07, mtk / Peter Zijlstra, Added description of RLIMIT_RTTIME
|
|
.\" 2010-11-06, mtk: Added documentation of prlimit()
|
|
.\"
|
|
.TH GETRLIMIT 2 2015-12-28 "Linux" "Linux Programmer's Manual"
|
|
.SH NAME
|
|
getrlimit, setrlimit, prlimit \- get/set resource limits
|
|
.SH SYNOPSIS
|
|
.B #include <sys/time.h>
|
|
.br
|
|
.B #include <sys/resource.h>
|
|
.sp
|
|
.BI "int getrlimit(int " resource ", struct rlimit *" rlim );
|
|
.br
|
|
.BI "int setrlimit(int " resource ", const struct rlimit *" rlim );
|
|
.sp
|
|
.BI "int prlimit(pid_t " pid ", int " resource \
|
|
", const struct rlimit *" new_limit ,
|
|
.br
|
|
.BI " struct rlimit *" old_limit );
|
|
.sp
|
|
.in -4n
|
|
Feature Test Macro Requirements for glibc (see
|
|
.BR feature_test_macros (7)):
|
|
.in
|
|
.sp
|
|
.BR prlimit ():
|
|
_GNU_SOURCE
|
|
.SH DESCRIPTION
|
|
The
|
|
.BR getrlimit ()
|
|
and
|
|
.BR setrlimit ()
|
|
system calls get and set resource limits respectively.
|
|
Each resource has an associated soft and hard limit, as defined by the
|
|
.I rlimit
|
|
structure:
|
|
.PP
|
|
.in +4n
|
|
.nf
|
|
struct rlimit {
|
|
rlim_t rlim_cur; /* Soft limit */
|
|
rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */
|
|
};
|
|
|
|
.fi
|
|
.in
|
|
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 set only 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
|
|
.B CAP_SYS_RESOURCE
|
|
capability) may make arbitrary changes to either limit value.
|
|
.PP
|
|
The value
|
|
.B RLIM_INFINITY
|
|
denotes no limit on a resource (both in the structure returned by
|
|
.BR getrlimit ()
|
|
and in the structure passed to
|
|
.BR setrlimit ()).
|
|
.PP
|
|
The
|
|
.I resource
|
|
argument must be one of:
|
|
.TP
|
|
.B RLIMIT_AS
|
|
The maximum size of the process's virtual memory (address space) in bytes.
|
|
.\" since 2.0.27 / 2.1.12
|
|
This limit affects calls to
|
|
.BR brk (2),
|
|
.BR mmap (2),
|
|
and
|
|
.BR mremap (2),
|
|
which fail with the error
|
|
.B ENOMEM
|
|
upon exceeding this limit.
|
|
Also automatic stack expansion will fail
|
|
(and generate a
|
|
.B SIGSEGV
|
|
that kills the process if no alternate stack
|
|
has been made available via
|
|
.BR sigaltstack (2)).
|
|
Since the value is a \fIlong\fP, on machines with a 32-bit \fIlong\fP
|
|
either this limit is at most 2 GiB, or this resource is unlimited.
|
|
.TP
|
|
.B RLIMIT_CORE
|
|
Maximum size of a
|
|
.I core
|
|
file (see
|
|
.BR core (5)).
|
|
When 0 no core dump files are created.
|
|
When nonzero, larger dumps are truncated to this size.
|
|
.TP
|
|
.B RLIMIT_CPU
|
|
CPU time limit in seconds.
|
|
When the process reaches the soft limit, it is sent a
|
|
.B 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
|
|
.B SIGXCPU
|
|
once per second until the hard limit is reached, at which time
|
|
it is sent
|
|
.BR SIGKILL .
|
|
(This latter point describes Linux behavior.
|
|
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
|
|
.BR SIGXCPU .)
|
|
.TP
|
|
.B RLIMIT_DATA
|
|
The maximum size of the process's data segment (initialized data,
|
|
uninitialized data, and heap).
|
|
This limit affects calls to
|
|
.BR brk (2)
|
|
and
|
|
.BR sbrk (2),
|
|
which fail with the error
|
|
.B ENOMEM
|
|
upon encountering the soft limit of this resource.
|
|
.TP
|
|
.B 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
|
|
.B 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.,
|
|
.BR write (2),
|
|
.BR truncate (2))
|
|
fails with the error
|
|
.BR EFBIG .
|
|
.TP
|
|
.BR RLIMIT_LOCKS " (Early Linux 2.4 only)"
|
|
.\" to be precise: Linux 2.4.0-test9; no longer in 2.4.25 / 2.5.65
|
|
A limit on the combined number of
|
|
.BR flock (2)
|
|
locks and
|
|
.BR fcntl (2)
|
|
leases that this process may establish.
|
|
.TP
|
|
.B RLIMIT_MEMLOCK
|
|
The maximum number of bytes of memory that may be locked
|
|
into RAM.
|
|
In effect this limit is rounded down to the nearest multiple
|
|
of the system page size.
|
|
This limit affects
|
|
.BR mlock (2)
|
|
and
|
|
.BR mlockall (2)
|
|
and the
|
|
.BR mmap (2)
|
|
.B MAP_LOCKED
|
|
operation.
|
|
Since Linux 2.6.9 it also affects the
|
|
.BR shmctl (2)
|
|
.B SHM_LOCK
|
|
operation, where it sets a maximum on the total bytes in
|
|
shared memory segments (see
|
|
.BR shmget (2))
|
|
that may be locked by the real user ID of the calling process.
|
|
The
|
|
.BR shmctl (2)
|
|
.B SHM_LOCK
|
|
locks are accounted for separately from the per-process memory
|
|
locks established by
|
|
.BR mlock (2),
|
|
.BR mlockall (2),
|
|
and
|
|
.BR mmap (2)
|
|
.BR MAP_LOCKED ;
|
|
a process can lock bytes up to this limit in each of these
|
|
two categories.
|
|
In Linux kernels before 2.6.9, this limit controlled the amount of
|
|
memory that could be locked by a privileged process.
|
|
Since Linux 2.6.9, no limits are placed on the amount of memory
|
|
that a privileged process may lock, and this limit instead governs
|
|
the amount of memory that an unprivileged process may lock.
|
|
.TP
|
|
.BR RLIMIT_MSGQUEUE " (since Linux 2.6.8)"
|
|
Specifies the limit on the number of bytes that can be allocated
|
|
for POSIX message queues for the real user ID of the calling process.
|
|
This limit is enforced for
|
|
.BR mq_open (3).
|
|
Each message queue that the user creates counts (until it is removed)
|
|
against this limit according to the formula:
|
|
.nf
|
|
|
|
Since Linux 3.5:
|
|
bytes = attr.mq_maxmsg * sizeof(struct msg_msg) +
|
|
min(attr.mq_maxmsg, MQ_PRIO_MAX) *
|
|
sizeof(struct posix_msg_tree_node)+
|
|
/* For overhead */
|
|
attr.mq_maxmsg * attr.mq_msgsize;
|
|
/* For message data */
|
|
|
|
Linux 3.4 and earlier:
|
|
bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) +
|
|
/* For overhead */
|
|
attr.mq_maxmsg * attr.mq_msgsize;
|
|
/* For message data */
|
|
|
|
.fi
|
|
where
|
|
.I attr
|
|
is the
|
|
.I mq_attr
|
|
structure specified as the fourth argument to
|
|
.BR mq_open (3),
|
|
and the
|
|
.I msg_msg
|
|
and
|
|
.I posix_msg_tree_node
|
|
structures are kernel-internal structures.
|
|
|
|
The "overhead" addend in the formula accounts for overhead
|
|
bytes required by the implementation
|
|
and ensures that the user cannot
|
|
create an unlimited number of zero-length messages (such messages
|
|
nevertheless each consume some system memory for bookkeeping overhead).
|
|
.TP
|
|
.BR RLIMIT_NICE " (since Linux 2.6.12, but see BUGS below)"
|
|
Specifies a ceiling to which the process's nice value can be raised using
|
|
.BR setpriority (2)
|
|
or
|
|
.BR nice (2).
|
|
The actual ceiling for the nice value is calculated as
|
|
.IR "20\ \-\ rlim_cur" .
|
|
(This strangeness occurs because negative numbers cannot be specified
|
|
as resource limit values, since they typically have special meanings.
|
|
For example,
|
|
.B RLIM_INFINITY
|
|
typically is the same as \-1.)
|
|
.TP
|
|
.B RLIMIT_NOFILE
|
|
Specifies a value one greater than the maximum file descriptor number
|
|
that can be opened by this process.
|
|
Attempts
|
|
.RB ( open (2),
|
|
.BR pipe (2),
|
|
.BR dup (2),
|
|
etc.)
|
|
to exceed this limit yield the error
|
|
.BR EMFILE .
|
|
(Historically, this limit was named
|
|
.B RLIMIT_OFILE
|
|
on BSD.)
|
|
.TP
|
|
.B RLIMIT_NPROC
|
|
The maximum number of processes (or, more precisely on Linux, threads)
|
|
that can be created for the real user ID of the calling process.
|
|
Upon encountering this limit,
|
|
.BR fork (2)
|
|
fails with the error
|
|
.BR EAGAIN .
|
|
This limit is not enforced for processes that have either the
|
|
.B CAP_SYS_ADMIN
|
|
or the
|
|
.B CAP_SYS_RESOURCE
|
|
capability.
|
|
.TP
|
|
.B RLIMIT_RSS
|
|
Specifies the limit (in bytes) of the process's resident set
|
|
(the number of virtual pages resident in RAM).
|
|
This limit has effect only in Linux 2.4.x, x < 30, and there
|
|
affects only calls to
|
|
.BR madvise (2)
|
|
specifying
|
|
.BR MADV_WILLNEED .
|
|
.\" As at kernel 2.6.12, this limit still does nothing in 2.6 though
|
|
.\" talk of making it do something has surfaced from time to time in LKML
|
|
.\" -- MTK, Jul 05
|
|
.TP
|
|
.BR RLIMIT_RTPRIO " (since Linux 2.6.12, but see BUGS)"
|
|
Specifies a ceiling on the real-time priority that may be set for
|
|
this process using
|
|
.BR sched_setscheduler (2)
|
|
and
|
|
.BR sched_setparam (2).
|
|
.TP
|
|
.BR RLIMIT_RTTIME " (since Linux 2.6.25)"
|
|
Specifies a limit (in microseconds)
|
|
on the amount of CPU time that a process scheduled
|
|
under a real-time scheduling policy may consume without making a blocking
|
|
system call.
|
|
For the purpose of this limit,
|
|
each time a process makes a blocking system call,
|
|
the count of its consumed CPU time is reset to zero.
|
|
The CPU time count is not reset if the process continues trying to
|
|
use the CPU but is preempted, its time slice expires, or it calls
|
|
.BR sched_yield (2).
|
|
|
|
Upon reaching the soft limit, the process is sent a
|
|
.B SIGXCPU
|
|
signal.
|
|
If the process catches or ignores this signal and
|
|
continues consuming CPU time, then
|
|
.B SIGXCPU
|
|
will be generated once each second until the hard limit is reached,
|
|
at which point the process is sent a
|
|
.B SIGKILL
|
|
signal.
|
|
|
|
The intended use of this limit is to stop a runaway
|
|
real-time process from locking up the system.
|
|
.TP
|
|
.BR RLIMIT_SIGPENDING " (since Linux 2.6.8)"
|
|
Specifies the limit on the number of signals
|
|
that may be queued for the real user ID of the calling process.
|
|
Both standard and real-time signals are counted for the purpose of
|
|
checking this limit.
|
|
However, the limit is enforced only for
|
|
.BR sigqueue (3);
|
|
it is always possible to use
|
|
.BR kill (2)
|
|
to queue one instance of any of the signals that are not already
|
|
queued to the process.
|
|
.\" This replaces the /proc/sys/kernel/rtsig-max system-wide limit
|
|
.\" that was present in kernels <= 2.6.7. MTK Dec 04
|
|
.TP
|
|
.B RLIMIT_STACK
|
|
The maximum size of the process stack, in bytes.
|
|
Upon reaching this limit, a
|
|
.B SIGSEGV
|
|
signal is generated.
|
|
To handle this signal, a process must employ an alternate signal stack
|
|
.RB ( sigaltstack (2)).
|
|
|
|
Since Linux 2.6.23,
|
|
this limit also determines the amount of space used for the process's
|
|
command-line arguments and environment variables; for details, see
|
|
.BR execve (2).
|
|
.SS prlimit()
|
|
.\" commit c022a0acad534fd5f5d5f17280f6d4d135e74e81
|
|
.\" Author: Jiri Slaby <jslaby@suse.cz>
|
|
.\" Date: Tue May 4 18:03:50 2010 +0200
|
|
.\"
|
|
.\" rlimits: implement prlimit64 syscall
|
|
.\"
|
|
.\" commit 6a1d5e2c85d06da35cdfd93f1a27675bfdc3ad8c
|
|
.\" Author: Jiri Slaby <jslaby@suse.cz>
|
|
.\" Date: Wed Mar 24 17:06:58 2010 +0100
|
|
.\"
|
|
.\" rlimits: add rlimit64 structure
|
|
.\"
|
|
The Linux-specific
|
|
.BR prlimit ()
|
|
system call combines and extends the functionality of
|
|
.BR setrlimit ()
|
|
and
|
|
.BR getrlimit ().
|
|
It can be used to both set and get the resource limits of an arbitrary process.
|
|
|
|
The
|
|
.I resource
|
|
argument has the same meaning as for
|
|
.BR setrlimit ()
|
|
and
|
|
.BR getrlimit ().
|
|
|
|
If the
|
|
.IR new_limit
|
|
argument is a not NULL, then the
|
|
.I rlimit
|
|
structure to which it points is used to set new values for
|
|
the soft and hard limits for
|
|
.IR resource .
|
|
If the
|
|
.IR old_limit
|
|
argument is a not NULL, then a successful call to
|
|
.BR prlimit ()
|
|
places the previous soft and hard limits for
|
|
.I resource
|
|
in the
|
|
.I rlimit
|
|
structure pointed to by
|
|
.IR old_limit .
|
|
|
|
The
|
|
.I pid
|
|
argument specifies the ID of the process on which the call is to operate.
|
|
If
|
|
.I pid
|
|
is 0, then the call applies to the calling process.
|
|
To set or get the resources of a process other than itself,
|
|
the caller must have the
|
|
.B CAP_SYS_RESOURCE
|
|
capability, or the
|
|
real, effective, and saved set user IDs of the target process
|
|
must match the real user ID of the caller
|
|
.I and
|
|
the real, effective, and saved set group IDs of the target process
|
|
must match the real group ID of the caller.
|
|
.\" FIXME . this permission check is strange
|
|
.\" Asked about this on LKML, 7 Nov 2010
|
|
.\" "Inconsistent credential checking in prlimit() syscall"
|
|
.SH RETURN VALUE
|
|
On success, these system calls return 0.
|
|
On error, \-1 is returned, and
|
|
.I errno
|
|
is set appropriately.
|
|
.SH ERRORS
|
|
.TP
|
|
.B EFAULT
|
|
A pointer argument points to a location
|
|
outside the accessible address space.
|
|
.TP
|
|
.B EINVAL
|
|
The value specified in
|
|
.I resource
|
|
is not valid;
|
|
or, for
|
|
.BR setrlimit ()
|
|
or
|
|
.BR prlimit ():
|
|
.I rlim\->rlim_cur
|
|
was greater than
|
|
.IR rlim\->rlim_max .
|
|
.TP
|
|
.B EPERM
|
|
An unprivileged process tried to raise the hard limit; the
|
|
.B CAP_SYS_RESOURCE
|
|
capability is required to do this.
|
|
.TP
|
|
.B EPERM
|
|
The caller tried to increase the hard
|
|
.B RLIMIT_NOFILE
|
|
limit above the maximum defined by
|
|
.IR /proc/sys/fs/nr_open
|
|
(see
|
|
.BR proc (5))
|
|
.TP
|
|
.B EPERM
|
|
.RB ( prlimit ())
|
|
The calling process did not have permission to set limits
|
|
for the process specified by
|
|
.IR pid .
|
|
.TP
|
|
.B ESRCH
|
|
Could not find a process with the ID specified in
|
|
.IR pid .
|
|
.SH VERSIONS
|
|
The
|
|
.BR prlimit ()
|
|
system call is available since Linux 2.6.36.
|
|
Library support is available since glibc 2.13.
|
|
.SH ATTRIBUTES
|
|
For an explanation of the terms used in this section, see
|
|
.BR attributes (7).
|
|
.TS
|
|
allbox;
|
|
lbw35 lb lb
|
|
l l l.
|
|
Interface Attribute Value
|
|
T{
|
|
.BR getrlimit (),
|
|
.BR setrlimit (),
|
|
.BR prlimit ()
|
|
T} Thread safety MT-Safe
|
|
.TE
|
|
|
|
.SH CONFORMING TO
|
|
.BR getrlimit (),
|
|
.BR setrlimit ():
|
|
POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.
|
|
.br
|
|
.BR prlimit ():
|
|
Linux-specific.
|
|
|
|
.B RLIMIT_MEMLOCK
|
|
and
|
|
.B RLIMIT_NPROC
|
|
derive from BSD and are not specified in POSIX.1;
|
|
they are present on the BSDs and Linux, but on few other implementations.
|
|
.B RLIMIT_RSS
|
|
derives from BSD and is not specified in POSIX.1;
|
|
it is nevertheless present on most implementations.
|
|
.BR RLIMIT_MSGQUEUE ,
|
|
.BR RLIMIT_NICE ,
|
|
.BR RLIMIT_RTPRIO ,
|
|
.BR RLIMIT_RTTIME ,
|
|
and
|
|
.B RLIMIT_SIGPENDING
|
|
are Linux-specific.
|
|
.SH NOTES
|
|
A child process created via
|
|
.BR fork (2)
|
|
inherits its parent's resource limits.
|
|
Resource limits are preserved across
|
|
.BR execve (2).
|
|
|
|
Lowering the soft limit for a resource below the process's
|
|
current consumption of that resource will succeed
|
|
(but will prevent the process from further increasing
|
|
its consumption of the resource).
|
|
|
|
One can set the resource limits of the shell using the built-in
|
|
.IR ulimit
|
|
command
|
|
.RI ( limit
|
|
in
|
|
.BR csh (1)).
|
|
The shell's resource limits are inherited by the processes that
|
|
it creates to execute commands.
|
|
|
|
Since Linux 2.6.24, the resource limits of any process can be inspected via
|
|
.IR /proc/[pid]/limits ;
|
|
see
|
|
.BR proc (5).
|
|
|
|
Ancient systems provided a
|
|
.BR vlimit ()
|
|
function with a similar purpose to
|
|
.BR setrlimit ().
|
|
For backward compatibility, glibc also provides
|
|
.BR vlimit ().
|
|
All new applications should be written using
|
|
.BR setrlimit ().
|
|
.SS C library/ kernel ABI differences
|
|
Since version 2.13, the glibc
|
|
.BR getrlimit ()
|
|
and
|
|
.BR setrlimit ()
|
|
wrapper functions no longer invoke the corresponding system calls,
|
|
but instead employ
|
|
.BR prlimit (),
|
|
for the reasons described in BUGS.
|
|
|
|
The name of the glibc wrapper function is
|
|
.BR prlimit ();
|
|
the underlying system call is call prlimit64 ().
|
|
.SH BUGS
|
|
In older Linux kernels, the
|
|
.B SIGXCPU
|
|
and
|
|
.B SIGKILL
|
|
signals delivered when a process encountered the soft and hard
|
|
.B RLIMIT_CPU
|
|
limits were delivered one (CPU) second later than they should have been.
|
|
This was fixed in kernel 2.6.8.
|
|
|
|
In 2.6.x kernels before 2.6.17, a
|
|
.B RLIMIT_CPU
|
|
limit of 0 is wrongly treated as "no limit" (like
|
|
.BR RLIM_INFINITY ).
|
|
Since Linux 2.6.17, setting a limit of 0 does have an effect,
|
|
but is actually treated as a limit of 1 second.
|
|
.\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=114008066530167&w=2
|
|
|
|
A kernel bug means that
|
|
.\" See https://lwn.net/Articles/145008/
|
|
.B RLIMIT_RTPRIO
|
|
does not work in kernel 2.6.12; the problem is fixed in kernel 2.6.13.
|
|
|
|
In kernel 2.6.12, there was an off-by-one mismatch
|
|
between the priority ranges returned by
|
|
.BR getpriority (2)
|
|
and
|
|
.BR RLIMIT_NICE .
|
|
This had the effect that the actual ceiling for the nice value
|
|
was calculated as
|
|
.IR "19\ \-\ rlim_cur" .
|
|
This was fixed in kernel 2.6.13.
|
|
.\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2
|
|
|
|
Since Linux 2.6.12,
|
|
.\" The relevant patch, sent to LKML, seems to be
|
|
.\" http://thread.gmane.org/gmane.linux.kernel/273462
|
|
.\" From: Roland McGrath <roland <at> redhat.com>
|
|
.\" Subject: [PATCH 7/7] make RLIMIT_CPU/SIGXCPU per-process
|
|
.\" Date: 2005-01-23 23:27:46 GMT
|
|
if a process reaches its soft
|
|
.BR RLIMIT_CPU
|
|
limit and has a handler installed for
|
|
.BR SIGXCPU ,
|
|
then, in addition to invoking the signal handler,
|
|
the kernel increases the soft limit by one second.
|
|
This behavior repeats if the process continues to consume CPU time,
|
|
until the hard limit is reached,
|
|
at which point the process is killed.
|
|
Other implementations
|
|
.\" Tested Solaris 10, FreeBSD 9, OpenBSD 5.0
|
|
do not change the
|
|
.BR RLIMIT_CPU
|
|
soft limit in this manner,
|
|
and the Linux behavior is probably not standards conformant;
|
|
portable applications should avoid relying on this Linux-specific behavior.
|
|
.\" FIXME . https://bugzilla.kernel.org/show_bug.cgi?id=50951
|
|
The Linux-specific
|
|
.BR RLIMIT_RTTIME
|
|
limit exhibits the same behavior when the soft limit is encountered.
|
|
|
|
Kernels before 2.4.22 did not diagnose the error
|
|
.B EINVAL
|
|
for
|
|
.BR setrlimit ()
|
|
when
|
|
.I rlim\->rlim_cur
|
|
was greater than
|
|
.IR rlim\->rlim_max .
|
|
.\"
|
|
.SS Representation of """large""" resource limit values on 32-bit platforms
|
|
The glibc
|
|
.BR getrlimit ()
|
|
and
|
|
.BR setrlimit ()
|
|
wrapper functions use a 64-bit
|
|
.IR rlim_t
|
|
data type, even on 32-bit platforms.
|
|
However, the
|
|
.I rlim_t
|
|
data type used in the
|
|
.BR getrlimit ()
|
|
and
|
|
.BR setrlimit ()
|
|
system calls is a (32-bit)
|
|
.IR "unsigned long" .
|
|
Furthermore, in Linux versions before 2.6.36,
|
|
the kernel represents resource limits on 32-bit platforms as
|
|
.IR "unsigned long" .
|
|
However, a 32-bit data type is not wide enough.
|
|
.\" https://bugzilla.kernel.org/show_bug.cgi?id=5042
|
|
.\" http://sources.redhat.com/bugzilla/show_bug.cgi?id=12201
|
|
The most pertinent limit here is
|
|
.BR RLIMIT_FSIZE ,
|
|
which specifies the maximum size to which a file can grow:
|
|
to be useful, this limit must be represented using a type
|
|
that is as wide as the type used to
|
|
represent file offsets\(emthat is, as wide as a 64-bit
|
|
.BR off_t
|
|
(assuming a program compiled with
|
|
.IR _FILE_OFFSET_BITS=64 ).
|
|
|
|
To work around this kernel limitation,
|
|
if a program tried to set a resource limit to a value larger than
|
|
can be represented in a 32-bit
|
|
.IR "unsigned long" ,
|
|
then the glibc
|
|
.BR setrlimit ()
|
|
wrapper function silently converted the limit value to
|
|
.BR RLIM_INFINITY .
|
|
In other words, the requested resource limit setting was silently ignored.
|
|
|
|
This problem was addressed in Linux 2.6.36 with two principal changes:
|
|
.IP * 3
|
|
the addition of a new kernel representation of resource limits that
|
|
uses 64 bits, even on 32-bit platforms;
|
|
.IP *
|
|
the addition of the
|
|
.BR prlimit ()
|
|
system call, which employs 64-bit values for its resource limit arguments.
|
|
.PP
|
|
Since version 2.13,
|
|
.\" https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201
|
|
glibc works around the limitations of the
|
|
.BR getrlimit ()
|
|
and
|
|
.BR setrlimit ()
|
|
system calls by implementing
|
|
.BR setrlimit ()
|
|
and
|
|
.BR getrlimit ()
|
|
as wrapper functions that call
|
|
.BR prlimit ().
|
|
.SH EXAMPLE
|
|
The program below demonstrates the use of
|
|
.BR prlimit ().
|
|
.PP
|
|
.nf
|
|
#define _GNU_SOURCE
|
|
#define _FILE_OFFSET_BITS 64
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/resource.h>
|
|
|
|
#define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \\
|
|
} while (0)
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
struct rlimit old, new;
|
|
struct rlimit *newp;
|
|
pid_t pid;
|
|
|
|
if (!(argc == 2 || argc == 4)) {
|
|
fprintf(stderr, "Usage: %s <pid> [<new\-soft\-limit> "
|
|
"<new\-hard\-limit>]\\n", argv[0]);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
pid = atoi(argv[1]); /* PID of target process */
|
|
|
|
newp = NULL;
|
|
if (argc == 4) {
|
|
new.rlim_cur = atoi(argv[2]);
|
|
new.rlim_max = atoi(argv[3]);
|
|
newp = &new;
|
|
}
|
|
|
|
/* Set CPU time limit of target process; retrieve and display
|
|
previous limit */
|
|
|
|
if (prlimit(pid, RLIMIT_CPU, newp, &old) == \-1)
|
|
errExit("prlimit\-1");
|
|
printf("Previous limits: soft=%lld; hard=%lld\\n",
|
|
(long long) old.rlim_cur, (long long) old.rlim_max);
|
|
|
|
/* Retrieve and display new CPU time limit */
|
|
|
|
if (prlimit(pid, RLIMIT_CPU, NULL, &old) == \-1)
|
|
errExit("prlimit\-2");
|
|
printf("New limits: soft=%lld; hard=%lld\\n",
|
|
(long long) old.rlim_cur, (long long) old.rlim_max);
|
|
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
.fi
|
|
.SH SEE ALSO
|
|
.BR prlimit (1),
|
|
.BR dup (2),
|
|
.BR fcntl (2),
|
|
.BR fork (2),
|
|
.BR getrusage (2),
|
|
.BR mlock (2),
|
|
.BR mmap (2),
|
|
.BR open (2),
|
|
.BR quotactl (2),
|
|
.BR sbrk (2),
|
|
.BR shmctl (2),
|
|
.BR malloc (3),
|
|
.BR sigqueue (3),
|
|
.BR ulimit (3),
|
|
.BR core (5),
|
|
.BR capabilities (7),
|
|
.BR signal (7)
|