getrlimit(2)							System Calls Manual						      getrlimit(2)

NAME

       getrlimit, setrlimit - Controls maximum system resource consumption

SYNOPSIS

       #include <sys/resource.h>

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

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

       [Tru64  UNIX]  The  following declaration of the setrlimit() function does not conform to current standards and is supported only for back-
       ward compatibility:

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

       [Tru64 UNIX]  Application developers may want to specify an #include statement for <sys/time.h> before the one for <sys/resource.h> if pro-
       grams  are  being  developed  for  multiple platforms. The additional #include statement is not required on Tru64 UNIX systems or by ISO or
       X/Open standards, but may be required on other vendors' systems that conform to these standards.

STANDARDS

       Interfaces documented on this reference page conform to industry standards as follows:

       getrlimit(), setrlimit(): XSH4.2

       Refer to the standards(5) reference page for more information about industry standards and associated tags.

PARAMETERS

       Specifies one of the following values: The maximum size, in bytes, of the total memory available to a process.  Exceeding this limit causes
       the  brk(), malloc(), mmap(), and sbrk() functions to fail with errno set to [ENOMEM].  Also, the automatic stack growth will fail with the
       effects described under RLIMIT_STACK.  The largest size, in bytes, of a core file that can be created.  A limit of 0  (zero)  prevents  the
       process	from creating a core file.  If a process exceeds this limit, any remaining data to be written to the core file is lost.  The maxi-
       mum amount of CPU time, in seconds, to be used by a process.  If the process exceeds this limit, the system sends the SIGXCPU signal to the
       process.   The  maximum	size,  in bytes, of a process's data segment.  Exceeding this limit causes the brk(), malloc(), mmap(), and sbrk()
       functions to fail with errno set to [ENOMEM].  The maximum size, in bytes, of any single file that can be created.  A  limit  of  0  (zero)
       prevents  the  process  from  creating a file.  If write attempts to extend a file already at its limit or a truncate operation would cause
       this limit to be exceeded, the system generates the SIGXFSZ signal. 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].  The maximum number of
       open file descriptors that the process can have.  Any functions that attempt to create new file descriptors when the maximum hard limit has
       been reached will fail with errno set to [EMFILE].

	      [Tru64  UNIX]  The default maximum is 4096 file descriptors. The maximum can be 64K file descriptors when a process has enabled sup-
	      port for more than  4096	open  file  descriptors.  See  the  discussion	of  the  open_max_hard	and  open_max_soft  attributes	in
	      sys_attrs_proc(5)  for  information  about increasing the soft and hard limits for open file descriptors.  [Tru64 UNIX]  The maximum
	      size, in bytes, to which a process's resident set size can grow.	This value imposes a limit on the amount of physical  memory  that
	      can  be given to a process.  If memory is in short supply, the system prefers to take memory from processes that are exceeding their
	      declared resident set size.  The maximum size, in bytes, of a process's stack. The system 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  is  set	to
	      SIG_DFL  before  it  is  generated.  Points to the rlimit structure, which contains the current soft and hard limits.  For the getr-
	      limit() function, the requested limits are returned in this structure; for the setrlimit() function,  the  desired  new  limits  are
	      specified here.

DESCRIPTION

       The getrlimit() function obtains the limits on the consumption of system resources by the current process and each process it creates.  You
       use the setrlimit() function to set these resources.

       Each resource limit is specified as either a soft limit or a hard limit.  When a soft limit is exceeded (for example, if the  CPU  time	is
       exceeded), a process can receive a signal until it reaches the hard limit or until it modifies its resource limit.  The rlimit structure is
       used to specify the hard and soft limits on a resource, as defined in the sys/resource.h header file.

       The calling process must have superuser privilege in order to raise the maximum limits.	An unprivileged process  can  alter  the  rlim_cur
       field of the rlimit structure within the range from 0 (zero) to rlim_max or can (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, and inherited by fork(), the setrlimit() function should be executed
       directly by the shell in order to affect all future processes created by the shell.  Thus, limit is a built-in command to the shells.

NOTES

       The ulimit() function is implemented in terms of setrlimit(). Therefore, the two interfaces should not be used in  the  same  program.  The
       result of doing so is undefined.

       [Tru64  UNIX]  When  compiled  in the X/Open UNIX environment, calls to the setrlimit() function are internally renamed by prepending _E to
       the function name. When you are debugging a module that includes the setrlimit() function and for  which  _XOPEN_SOURCE_EXTENDED  has  been
       defined, use _Esetrlimit to refer to the setrlimit() call.  See standards(5) for additional information.

RETURN VALUES

       Upon  successful  completion,  these  functions return a value of 0 (zero).  Otherwise, the functions return a value of -1 and set errno to
       indicate the error.

ERRORS

       If the getrlimit() or setrlimit() function fails, errno might be set to one of the following values: [Tru64  UNIX]  The	address  specified
       for  the  rlp parameter is invalid.  An invalid resource was specified, or the new rlim_cur specified in a setrlimit() call exceeds the new
       rlim_max specified in that same call.  The limit specified to the setrlimit() function would have raised the maximum limit value,  and  the
       calling process does not have appropriate privilege.

RELATED INFORMATION

       Functions: quotactl(2), setsysinfo(2), sigaction(2), sigstack(2), sigvec(2), ulimit(3)

       Standards: standards(5) delim off

																      getrlimit(2)