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

FreeBSD Manual Pages


home | help
GETRLIMIT(2)		      System Calls Manual		  GETRLIMIT(2)

       getrlimit, setrlimit - control maximum system resource consumption

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

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

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

       Limits  on  the	consumption of system resources	by the current process
       and each	process	it creates may be obtained with	the getrlimit()	 call,
       and set with the	setrlimit() call.

       The resource parameter is one of	the following:

       RLIMIT_CPU	   the	maximum	 amount	of cpu time (in	seconds) to be
			   used	by each	process.

       RLIMIT_FSIZE	   the largest size, in	bytes, of any single file that
			   may be created.

       RLIMIT_DATA	   the maximum size, in	bytes, of the data segment for
			   a process; this defines how far a program  may  ex-
			   tend	 its break with	the sbrk() (see	brk(2))	system

       RLIMIT_STACK	   the maximum size, in	bytes, of  the	stack  segment
			   for	a  process;  this  defines how far a program's
			   stack segment may be	extended automatically by  the

       RLIMIT_CORE	   the largest size, in	bytes, of a core file that may
			   be created.

       RLIMIT_RSS	   the maximum size, in	bytes, to  which  a  process's
			   resident  set  size may grow.  This imposes a limit
			   on the amount of physical memory to be given	 to  a
			   process; if memory is tight,	the system will	prefer
			   to take memory from processes  that	are  exceeding
			   their declared resident set size.

       RLIMIT_NOFILE	   one more than the maximum value that	the system may
			   assign to a newly created descriptor.   This	 limit
			   constrains the number of descriptors	that a process
			   may create.

       A resource limit	is specified as	a soft limit and a hard	limit.	When a
       soft  limit is exceeded a process may receive a signal (for example, if
       the cpu time is exceeded), but it will be allowed to continue execution
       until  it reaches the hard limit	(or modifies its resource limit).  The
       rlimit structure	is used	to specify the hard and	soft limits on	a  re-

	      struct rlimit {
		   int	rlim_cur; /* current (soft) limit */
		   int	rlim_max; /* hard limit	*/

       Only the	super-user may raise the maximum limits.  Other	users may only
       alter rlim_cur within the range from 0 to  rlim_max  or	(irreversibly)
       lower rlim_max.

       An   "infinite"	 value	 for  a	 limit	is  defined  as	 RLIM_INFINITY

       Because this information	is stored in the per-process information, this
       system  call  must be executed directly by the shell if it is to	affect
       all future processes created by the shell; limit	 is  thus  a  built-in
       command to csh(1).

       The  system  refuses  to	extend the data	or stack space when the	limits
       would be	exceeded in the	normal way: a brk() or sbrk() call  will  fail
       if  the	data  space  limit  is	reached, or the	process	will be	sent a
       SIGSEGV when the	stack limit is reached which will kill the process un-
       less  SIGSEGV  is  handled  on a	separate signal	stack (since the stack
       cannot be extended, there is no way to send a signal!).

       A file I/O operation that would create a	file that is too large	gener-
       ates a signal SIGXFSZ; this normally terminates the process, but	may be
       caught.	When the soft CPU time limit is	exceeded, a signal SIGXCPU  is
       sent to the offending process.

       getrlimit() and setrlimit() return:

       0      on success.

       -1     on failure and set errno to indicate the error.

       EFAULT	      The address specified by rlp was invalid.

       EINVAL	      An invalid resource was specified.

       In addition to the above, setrlimit() may set errno to:

       EINVAL	      The new rlim_cur exceeds the new rlim_max.

       EPERM	      The  limit specified would have raised the maximum limit
		      value, and the caller was	not the	super-user.

       csh(1), sh(1), brk(2), getdtablesize(2),	quotactl(2)

       There should be limit and unlimit commands  in  sh(1)  as  well	as  in

				21 January 1990			  GETRLIMIT(2)


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

home | help