Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (SunOS-4.1.3)
Apropos / Subsearch:
optional field

GETRLIMIT(2)                  System Calls Manual                 GETRLIMIT(2)

       getrlimit, setrlimit - control maximum system resource consumption

       #include <&lt;sys/time.h>&gt;
       #include <&lt;sys/resource.h>&gt;

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

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

       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_CPU          the  maximum  amount of cpu time (in seconds) to be
                           used by each process.

       RLIMIT_FSIZE        the largest size, in bytes, of any single file that
                           may be created.

       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() (see brk(2)) sys-
                           tem call.

       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 automatically by  the

       RLIMIT_CORE         the largest size, in bytes, of a core file that may
                           be created.

       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_NOFILE       one more than the maximum value that the system may
                           assign to a newly created descriptor.   This  limit
                           constrains the number of descriptors that a process
                           may create.

       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 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

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

       Only the super-user 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

       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).

       The  system  refuses  to extend the data or stack space when the limits
       would be exceeded in the normal way: a brk() or sbrk() call  will  fail
       if  the  data  space  limit  is  reached, or the process will be sent a
       SIGSEGV when the stack limit is reached which  will  kill  the  process
       unless  SIGSEGV  is handled on a separate signal stack (since the stack
       cannot be extended, there is no way to send a signal!).

       A file I/O operation that would create a file that is too large  gener-
       ates a signal SIGXFSZ; 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.

       getrlimit() and setrlimit() return:

       0      on success.

       -1     on failure and set errno to indicate the error.

       EFAULT         The address specified by rlp was invalid.

       EINVAL         An invalid resource was specified.

       In addition to the above, setrlimit() may set errno to:

       EINVAL         The new rlim_cur exceeds the new rlim_max.

       EPERM          The  limit specified would have raised the maximum limit
                      value, and the caller was not the super-user.

       csh(1), sh(1), brk(2), getdtablesize(2), quotactl(2)

       There should be limit and unlimit commands  in  sh(1)  as  well  as  in

                                21 January 1990                   GETRLIMIT(2)