getrlimit(2)							System Calls Manual						      getrlimit(2)

NAME

       getrlimit(), setrlimit() - control maximum resource consumption

SYNOPSIS

DESCRIPTION

       Limits on the consumption of a variety of resources by the calling process may be obtained with and set with Each call to either or identi-
       fies a specific resource to be operated upon as well as a resource limit.  A resource limit is represented by an structure, pointed  to	by
       the rlp argument and includes the following members:

	      rlim_t rlim_cur;	      /* Current (soft) limit */
	      rlim_t rlim_max;	      /* Hard limit */

       The member specifies the current or soft limit and the member specifies the maximum or hard limit.  Soft limits may be changed by a process
       to any value that is less than or equal to the hard limit.  A process may (irreversibly) lower its hard limit to any value that is  greater
       than  or  equal	to  the  soft limit.  Only a process with appropriate privileges can raise a hard limit.  Both hard and soft limits can be
       changed in a single call to subject to the constraints described above.

       The value defined in is considered to be larger than any other limit value.  If a call to returns for a resource, it means the  implementa-
       tion does not enforce limits on that resource.  Specifying as any resource limit value on a successful call to inhibits enforcement of that
       resource limit.

       The following resources are defined:

       This is the maximum size of a core file in bytes that may
			     be created by a process.  A limit of 0 will prevent the creation of a core file.  If  this  limit	is  exceeded,  the
			     writing of a core file will terminate at this size.

       This is the maximum amount of CPU time in seconds used
			     by  a  process.   If this limit is exceeded, is generated for the process.  The default action is to kill the process
			     and leave a core file.

       This is the maximum size of a process data segment in bytes.
			     If this limit is exceeded, the and functions will fail with set to ENOMEM.  The upper limit is enforced  through  the
			     tunable  However  setting	to will delay the upper limit enforcement until the resource is allocated for the applica-
			     tion.

       This is the maximum size of a file in bytes that may be created
			     by a process.  A limit of 0 will prevent the creation of a file.  If a write or truncate operation would  cause  this
			     limit  to	be  exceeded,  is  generated  for the process.	If the process is blocking, catching or ignoring continued
			     attempts to increase the size of a file from end-of-file to beyond the limit will fail with set to

       This is a number one greater than the maximum value that the system
			     may assign to a newly-created descriptor.	If this limit is exceeded, functions that allocate  new  file  descriptors
			     may fail with set to This limit constrains the number of file descriptors that a process may allocate.

       This is the maximum size of a process stack in bytes.
			     The  implementation will not automatically grow the stack beyond this limit.  If this limit is exceeded, is generated
			     for the process.  If the process is blocking or ignoring or is catching and has  not  made  arrangements  to  use	an
			     alternate	stack,	the disposition of will be set to before it is generated.  The upper limit is enforced through the
			     tunable However setting to will delay the upper limit enforcement until the resource is allocated	for  the  applica-
			     tion.

       This is the maximum size of a process's total available memory,
			     in bytes.	If this limit is exceeded, the and functions will fail with set to In addition, the automatic stack growth
			     will fail with the effects outlined above.

       This is the maximum number of POSIX Asynchronous I/O operations
			     that a process can have enqueued simultaneously.  If this limit is exceeded, the and functions will fail with set to

       This is the maximum number of bytes of memory that can be locked
			     simultaneously by POSIX Asynchronous I/O requests from a single process.

   Security Restrictions
       Raising hard limits with the call requires the privilege (PRIV_LIMIT).  Processes owned by the superuser have  this  privilege.	 Processes
       owned by other users may have this privilege, depending on system configuration.

       See privileges(5) for more information about privileged access on systems that support fine-grained privileges.

RETURN VALUE

       Upon successful completion, and return 0.  Otherwise, these functions return -1 and set to indicate the error.

ERRORS

       The and functions will fail if:

	      The address specified for
			     rlp is invalid.  Reliable detection of this error is implementation dependent.

	      An invalid resource was specified; or in a
			     call, the new rlim_cur exceeds the new rlim_max.

	      The limit specified to
			     would have raised the maximum limit value, and the calling process does not have appropriate privileges.

       The function may fail if:

	      The limit specified cannot be lowered because current usage is
			     already higher than the limit.

	      A user with appropriate privileges has attempted to raise
			     rlp->rlim_cur or rlp->rlim_max to a value greater than the system is capable of supporting.

	      The value of   rlp->rlim_cur is less than the number of file descriptors the process already has allocated.

	      The value of   rlp->rlim_max is less than the current soft limit.

	      The	     rlp  argument  specified  a hard or soft limit higher than the current hard limit value, and the caller does not have
			     the appropriate privileges.

WARNINGS

       The maximum size of a file returned by is in terms of bytes.  The maximum size of a file returned by (see ulimit(2)) with is  in  terms	of
       blocks of size 512 bytes.  The value returned by with may thus have to be rounded down to a multiple of 512.

       The  total address space used by a process depends on the platform it is run on.  When porting applications, limits set by with may need to
       be adjusted.  For example, programs tend to use more memory on systems than on PA-RISC systems.

AUTHOR

       and were developed by HP, AT&T, and the University of California, Berkeley.

SEE ALSO

       brk(2), creat64(2), exec(2), fork(2), open(2), sigaltstack(2), sysconf(2), ulimit(2), malloc(3C), maxdsiz(5), maxssiz(5).

																      getrlimit(2)