unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (HP-UX-11.11)
Page:
Section:
Apropos / Subsearch:
optional field



 getrlimit(2)							getrlimit(2)




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

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

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

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

 DESCRIPTION
      Limits on the consumption of a variety of resources by the calling
      process may be obtained with getrlimit() and set with setrlimit().
      Each call to either getrlimit() or setrlimit() identifies a specific
      resource to be operated upon as well as a resource limit.	 A resource
      limit is represented by an rlimit 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 rlim_cur member specifies the current or soft limit and the
      rlim_max 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 setrlimit() subject to
      the constraints described above.

      The value RLIM_INFINITY, defined in <sys/resource.h>, is considered to
      be larger than any other limit value.  If a call to getrlimit()
      returns RLIM_INFINITY for a resource, it means the implementation does
      not enforce limits on that resource.  Specifying RLIM_INFINITY as any
      resource limit value on a successful call to setrlimit() inhibits
      enforcement of that resource limit.

      The following resources are defined:

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

	   RLIMIT_CPU		    This is the maximum amount of CPU time
				    in seconds allowed for a UNIX 95
				    conforming application.  If this limit
				    is exceeded, SIGXCPU is generated for
				    the application.  The default action for



 Hewlett-Packard Company	    - 1 -   HP-UX Release 11i: November 2000






 getrlimit(2)							getrlimit(2)




				    a UNIX 95 conforming application is to
				    kill the process and leave a core file.
				    If the process is blocking, catching or
				    ignoring SIGXCPU, the behavior is
				    unspecified.  If the application is a
				    Classic HP-UX application, the kernel
				    will not send the signal as a result of
				    exceeding the CPU limit.  However, if
				    this signal is sent explicitly to a
				    Classic HP-UX application by another
				    application or via the kill -XCPU
				    command, this signal will be delivered
				    and the default action will be taken.
				    In order for an application to be UNIX
				    95, it must be linked with unix95.o
				    either directly or indirectly.  For
				    example:


				    % cc /usr/lib/unix95.o prog.c

				    Or,

				    % export UNIX95=1
				    % cc prog.c

	   RLIMIT_DATA		    This is the maximum size of a process'
				    data segment in bytes.  If this limit is
				    exceeded, the brk(), malloc(), and
				    sbrk() functions will fail with errno
				    set to ENOMEM.

	   RLIMIT_FSIZE		    This option is only applicable to UNIX
				    95 conforming applications.	 Please see
				    RLIMIT_CPU option above for explanation
				    on UNIX 95 conforming applications.
				    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, SIGXFSZ is generated for the
				    process.  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.

	   RLIMIT_NOFILE	    This is a number one greater than the
				    maximum value that the system may assign
				    to a newly-created descriptor.  If this



 Hewlett-Packard Company	    - 2 -   HP-UX Release 11i: November 2000






 getrlimit(2)							getrlimit(2)




				    limit is exceeded, functions that
				    allocate new file descriptors may fail
				    with errno set to EMFILE.  This limit
				    constrains the number of file
				    descriptors that a process may allocate.

	   RLIMIT_STACK		    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,
				    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 will be set to SIG_DFL before it
				    is generated.

	   RLIMIT_AS		    This is the maximum size of a process'
				    total available memory, in bytes.  If
				    this limit is exceeded, the brk(),
				    malloc(), mmap(), and sbrk() functions
				    will fail with errno set to ENOMEM.	 In
				    addition, the automatic stack growth
				    will fail with the effects outlined
				    above.

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

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

 RETURN VALUE
      Upon successful completion, getrlimit() and setrlimit() return 0.
      Otherwise, these functions return -1 and set errno to indicate the
      error.

 ERRORS
      The getrlimit() and setrlimit() functions will fail if:

	   [EINVAL]	  An invalid resource was specified; or in a
			  setrlimit() call, the new rlim_cur exceeds the new
			  rlim_max.



 Hewlett-Packard Company	    - 3 -   HP-UX Release 11i: November 2000






 getrlimit(2)							getrlimit(2)




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

	   [EPERM]	  The limit specified to setrlimit() would have
			  raised the maximum limit value, and the calling
			  process does not have appropriate privileges.

      The setrlimit() function may fail if:

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

	   [EPERM]	  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.

	   [EINVAL]	  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.

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

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

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

 AUTHOR
      getrlimit() and setrlimit() were developed by HP, AT&T, and the
      University of California, Berkeley.

 SEE ALSO
      brk(2), exec(2), fork(2), creat64(2), malloc(3C), open(2),
      sigaltstack(2), sysconf(2), ulimit(2), <stropts.h>, <sys/resource.h>.

 CHANGE HISTORY
      First released in Issue 4, Version 2.









 Hewlett-Packard Company	    - 4 -   HP-UX Release 11i: November 2000