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

FreeBSD Manual Pages


home | help
GETRLIMIT(2)		   Linux Programmer's Manual		  GETRLIMIT(2)

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

       #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);

       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-

	    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-

       resource	must be	one of:

	      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 re-
	      ceipt of SIGXCPU.)

	      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  en-
	      countering the soft limit	of this	resource.

	      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.

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

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

	      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  EM-

	      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.

	      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.

	      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-

       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 */

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

       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.

       SVr4, BSD 4.3

       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 re-
       source 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.

       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-

Linux				  2002-07-09			  GETRLIMIT(2)


Want to link to this manual page? Use this URL:

home | help