Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
GETRLIMIT(2)		   Linux Programmer's Manual		  GETRLIMIT(2)

NAME
       getrlimit, getrusage, setrlimit - get/set resource limits and usage

SYNOPSIS
       #include	<sys/time.h>
       #include	<sys/resource.h>
       #include	<unistd.h>

       int getrlimit(int resource, struct rlimit *rlim);
       int getrusage(int who, struct rusage *usage);
       int setrlimit(int resource, const struct	rlimit *rlim);

DESCRIPTION
       getrlimit and setrlimit get and set resource limits respectively.  Each
       resource	has an associated soft and  hard  limit,  as  defined  by  the
       rlimit  structure  (the	rlim  argument	to  both getrlimit() and setr-
       limit()):

	    struct rlimit {
		rlim_t rlim_cur;   /* Soft limit */
		rlim_t rlim_max;   /* Hard limit (ceiling
				      for rlim_cur) */
	    };

       The soft	limit is the value that	the kernel  enforces  for  the	corre-
       sponding	 resource.   The  hard	limit  acts  as	a ceiling for the soft
       limit: an unprivileged process may only set its soft limit to  a	 value
       in  the range from 0 up to the hard limit, and (irreversibly) lower its
       hard limit.  A privileged process may make arbitrary changes to	either
       limit value.

       The  value  RLIM_INFINITY  denotes  no limit on a resource (both	in the
       structure returned by getrlimit() and in	the structure passed to	 setr-
       limit()).

       resource	must be	one of:

       RLIMIT_CPU
	      CPU  time	 limit	in seconds.  When the process reaches the soft
	      limit, it	is sent	a SIGXCPU signal.  The default action for this
	      signal  is to terminate the process.  However, the signal	can be
	      caught, and the handler can return control to the	main  program.
	      If  the  process	continues to consume CPU time, it will be sent
	      SIGXCPU once per second until the	 hard  limit  is  reached,  at
	      which  time  it  is  sent	SIGKILL.  (This	latter point describes
	      Linux 2.2	and 2.4	behaviour.  Implementations vary in  how  they
	      treat  processes which continue to consume CPU time after	reach-
	      ing the soft limit.  Portable applications that  need  to	 catch
	      this  signal  should  perform  an	orderly	termination upon first
	      receipt of SIGXCPU.)

       RLIMIT_DATA
	      The maximum size of  the	process's  data	 segment  (initialized
	      data,  uninitialized  data, and heap).  This limit affects calls
	      to brk() and sbrk(), which  fail	with  the  error  ENOMEM  upon
	      encountering the soft limit of this resource.

       RLIMIT_FSIZE
	      The maximum size of files	that the process may create.  Attempts
	      to extend	a file beyond this  limit  result  in  delivery	 of  a
	      SIGXFSZ  signal.	 By default, this signal terminates a process,
	      but a process can	catch this signal instead, in which  case  the
	      relevant	system call (e.g., write(), truncate())	fails with the
	      error EFBIG.

       RLIMIT_LOCKS
	      A	limit on the combined number  of  flock()  locks  and  fcntl()
	      leases that this process may establish (Linux 2.4	and later).

       RLIMIT_MEMLOCK
	      The maximum number of bytes of virtual memory that may be	locked
	      into RAM using mlock() and mlockall().

       RLIMIT_NOFILE
	      Specifies	a value	one greater than the maximum  file  descriptor
	      number  that  can	 be opened by this process.  Attempts (open(),
	      pipe(), dup(), etc.)  to	exceed	this  limit  yield  the	 error
	      EMFILE.

       RLIMIT_NPROC
	      The maximum number of processes that can be created for the real
	      user ID of the calling process.  Upon encountering  this	limit,
	      fork() fails with	the error EAGAIN.

       RLIMIT_RSS
	      Specifies	 the  limit  (in  pages) of the	process's resident set
	      (the number of virtual pages resident in RAM).  This limit  only
	      has  effect  in Linux 2.4	onwatrds, and there only affects calls
	      to madvise() specifying MADVISE_WILLNEED.

       RLIMIT_STACK
	      The maximum size of the process stack, in	bytes.	Upon  reaching
	      this  limit, a SIGSEGV signal is generated.  To handle this sig-
	      nal, a process must employ an alternate  signal  stack  (sigalt-
	      stack(2)).

       RLIMIT_OFILE is the BSD name for	RLIMIT_NOFILE.

       getrusage  returns  the	current	 resource  usages, for a who of	either
       RUSAGE_SELF or RUSAGE_CHILDREN.	The former asks	for resources used  by
       the  current  process,  the  latter  for	resources used by those	of its
       children	that have terminated and have been waited for.

	    struct rusage {
		struct timeval ru_utime; /* user time used */
		struct timeval ru_stime; /* system time	used */
		long   ru_maxrss;	 /* maximum resident set size */
		long   ru_ixrss;	 /* integral shared memory size	*/
		long   ru_idrss;	 /* integral unshared data size	*/
		long   ru_isrss;	 /* integral unshared stack size */
		long   ru_minflt;	 /* page reclaims */
		long   ru_majflt;	 /* page faults	*/
		long   ru_nswap;	 /* swaps */
		long   ru_inblock;	 /* block input	operations */
		long   ru_oublock;	 /* block output operations */
		long   ru_msgsnd;	 /* messages sent */
		long   ru_msgrcv;	 /* messages received */
		long   ru_nsignals;	 /* signals received */
		long   ru_nvcsw;	 /* voluntary context switches */
		long   ru_nivcsw;	 /* involuntary	context	switches */
	    };

RETURN VALUE
       On success, zero	is returned.  On error,	-1 is returned,	and  errno  is
       set appropriately.

ERRORS
       EFAULT rlim or usage points outside the accessible address space.

       EINVAL getrlimit	 or  setrlimit	is  called  with  a  bad  resource, or
	      getrusage	is called with a bad who.

       EPERM  A	non-superuser tries to use setrlimit() to increase the soft or
	      hard limit above the current hard	limit, or a superuser tries to
	      increase RLIMIT_NOFILE above the current kernel maximum.

CONFORMING TO
       SVr4, BSD 4.3

NOTE
       Including _sys/time.h_ is not required these days, but increases	porta-
       bility.	(Indeed, struct	timeval	is defined in _sys/time.h_.)

       On  Linux,  if  the  disposition	 of SIGCHLD is set to SIG_IGN then the
       resource	usages of child	processes are automatically  included  in  the
       value  returned	by RUSAGE_CHILDREN, although POSIX 1003.1-2001 explic-
       itly prohibits this.

       The above struct	was taken from BSD 4.3 Reno.  Not all fields are mean-
       ingful  under  Linux.   Right now (Linux	2.4) only the fields ru_utime,
       ru_stime, ru_minflt, ru_majflt, and ru_nswap are	maintained.

SEE ALSO
       dup(2), fcntl(2), fork(2),  mlock(2),  mlockall(2),  mmap(2),  open(2),
       quotactl(2),  sbrk(2),  wait3(2),  wait4(2), malloc(3), ulimit(3), sig-
       nal(7)

Linux				  2002-07-09			  GETRLIMIT(2)

NAME | SYNOPSIS | DESCRIPTION | RETURN VALUE | ERRORS | CONFORMING TO | NOTE | SEE ALSO

Want to link to this manual page? Use this URL:
<http://www.freebsd.org/cgi/man.cgi?query=setrlimit&sektion=2&manpath=Red+Hat+Linux%2fi386+9>

home | help