NAME    [Toc]    [Back]

     getrlimit, setrlimit - control maximum system resource  consumption

SYNOPSIS    [Toc]    [Back]

     #include <sys/types.h>
     #include <sys/time.h>
     #include <sys/resource.h>

     int
     getrlimit(int resource, struct rlimit *rlp);

     int
     setrlimit(int resource, const struct rlimit *rlp);

DESCRIPTION    [Toc]    [Back]

     Limits on the consumption of system resources by the current
process and
     each process it creates may be obtained with the getrlimit()
call, and
     set with the setrlimit() call.

     The resource parameter is one of the following:

     RLIMIT_CORE      The  largest size (in bytes) core file that
may be created.


     RLIMIT_CPU      The maximum amount of CPU time (in  seconds)
to be used by
                     each process.

     RLIMIT_DATA     The maximum size (in bytes) of the data segment for a
                     process; this defines how far a program  may
extend its
                     break with the sbrk(2) system call.

     RLIMIT_FSIZE    The largest size (in bytes) file that may be
created.

     RLIMIT_MEMLOCK  The maximum size (in bytes) which a  process
may lock into
                     memory using the mlock(2) function.

     RLIMIT_NOFILE    The  maximum  number of open files for this
process.

     RLIMIT_NPROC    The maximum number of simultaneous processes
for this user
 id.

     RLIMIT_RSS       The maximum size (in bytes) to which a process's resident
                     set size may grow.  This imposes a limit  on
the amount of
                     physical memory to be given to a process; if
memory is
                     tight, the system will prefer to take memory
from processes
  that  are  exceeding  their declared
resident set
                     size.

     RLIMIT_STACK    The maximum size (in  bytes)  of  the  stack
segment for a
                     process;  this  defines  how far a program's
stack segment
                     may be extended.  Stack  extension  is  performed automatically
 by the system.

     A  resource  limit  is  specified as a soft limit and a hard
limit.  When a
     soft limit is exceeded a process may receive a  signal  (for
example, if
     the  CPU  time or file size is exceeded), but it will be allowed to continue
 execution until it reaches the hard  limit  (or  modifies
its resource
     limit).   The  rlimit  structure is used to specify the hard
and soft limits
     on a resource,

           struct rlimit {
                   rlim_t  rlim_cur;       /* current (soft) limit */
                   rlim_t  rlim_max;       /* hard limit */
           };

     Only  the  superuser  may  raise  the maximum limits.  Other
users may only
     alter rlim_cur within the range from 0 to rlim_max or (irreversibly) lower
 rlim_max.

     An ``infinite'' value for a limit is defined as RLIM_INFINITY.

     A value of RLIM_SAVED_CUR or RLIM_SAVED_MAX will  be  stored
in rlim_cur or
     rlim_max  respectively  by  getrlimit() if the value for the
current or maximum
 resource limit cannot be stored in an rlim_t.  The values
     RLIM_SAVED_CUR  and  RLIM_SAVED_MAX  should not be used in a
call to
     setrlimit() unless they were returned by a previous call  to
getrlimit().

     Because this information is stored in the per-process information, this
     system call must be executed directly by the shell if it  is
to affect all
     future  processes  created  by  the  shell;  limit is thus a
built-in command
     to csh(1) and ulimit is the sh(1) equivalent.

     The system refuses to extend the data or  stack  space  when
the limits
     would  be exceeded in the normal way: a brk(2) call fails if
the data
     space limit is reached.  When the stack  limit  is  reached,
the process receives
 a segmentation fault (SIGSEGV); if this signal is not
caught by a
     handler using the signal stack, this signal  will  kill  the
process.

     A  file  I/O  operation that would create a file larger than
the process'
     soft limit will cause the write to fail and a signal SIGXFSZ
to be generated;
  this  normally  terminates  the  process,  but may be
caught.  When the
     soft CPU time limit is exceeded, a signal SIGXCPU is sent to
the offending
 process.

RETURN VALUES    [Toc]    [Back]

     A 0 return value indicates that the call succeeded, changing
or returning
     the resource limit.  A return value of -1 indicates that  an
error occurred,
  and  an error code is stored in the global variable
errno.

ERRORS    [Toc]    [Back]

     getrlimit() and setrlimit() will fail if:

     [EFAULT]      The address specified for rlp is invalid.

     [EPERM]       The limit specified to setrlimit() would  have
raised the
                   maximum limit value, and the caller is not the
superuser.

SEE ALSO    [Toc]    [Back]

     csh(1), sh(1),  quotactl(2),  sigaction(2),  sigaltstack(2),
sysctl(3)

STANDARDS    [Toc]    [Back]

     The  getrlimit() and setrlimit() function calls are expected
to conform to
     IEEE Std 1003.1-2003 (``POSIX'').

HISTORY    [Toc]    [Back]

     The getrlimit() function call appeared in 4.2BSD.

OpenBSD      3.6                           June      4,      1993