Index for Section 2

Alphabetical listing for G

Bottom of page

getrlimit(2)
NAME
  getrlimit, setrlimit - Control maximum system resource consumption

SYNOPSIS
  #include <sys/resource.h>

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

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

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

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

  int setrlimit
	  int resource1,
	  struct rlimit *rlp );

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

  getrlimit(), setrlimit(): XSH4.2, XSH5.0

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

PARAMETERS
  resource1
      Specifies one of the following values:

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

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

      RLIMIT_CPU
	  The maximum 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.

      RLIMIT_DATA
	  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].

      RLIMIT_FSIZE
	  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].

      RLIMIT_NOFILE
	  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
	  support for more than 4096 open file descriptors. See the
	  discussion of the open_max_hard and open_max_soft system attributes
	  in sys_attrs_proc(5) for information about increasing the soft and
	  hard limits for open file descriptors.

      RLIMIT_RSS
	  [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.

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

  rlp Points to the rlimit structure, which contains the current soft and
      hard limits.  For the getrlimit() 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, which means that
  no limit is enforced for the specified resource.

  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, rlimit 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 is set to one of
  the following values for the specified conditions:

  [EFAULT]
      [Tru64 UNIX]  The address specified for the rlp parameter is invalid.

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

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

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

  Standards: standards(5)

Index for Section 2

Alphabetical listing for G

Top of page