FreeBSD Man Pages

limits(1)

NAME

     limits -- set or display process resource limits

SYNOPSIS

     limits [-C class | -U user] [-SHB] [-ea] [-bcdflmnstuv [val]]
     limits [-C class | -U user] [-SHB] [-bcdflmnstuv [val]] [-E]
	    [[name=value ...] command]

DESCRIPTION

     The limits utility either prints or sets kernel resource limits, and may
     optionally set environment variables like env(1) and run a program with
     the selected resources.  Three uses of the limits utility are possible:

     limits [limitflags] [name=value ...] command
	     This usage sets limits according to limitflags, optionally sets
	     environment variables given as name=value pairs, and then runs
	     the specified command.

     limits [limitflags]
	     This usage determines values of resource settings according to
	     limitflags, does not attempt to set them and outputs these values
	     to standard output.  By default, this will output the current
	     kernel resource settings active for the calling process.  Using
	     the -C class or -U user options, you may also display the current
	     resource settings modified by the appropriate login class
	     resource limit entries from the login.conf(5) login capabilities
	     database.

     limits -e [limitflags]
	     This usage determines values of resource settings according to
	     limitflags, but does not set them itself.	Like the previous
	     usage, it outputs these values to standard output, except that it
	     will emit them in eval format, suitable for the calling shell.
	     The calling shell is determined by examining the entries in the
	     /proc file system for the parent process.	If the shell is known
	     (i.e., it is one of sh, csh, bash, tcsh, ksh, pdksh or rc),
	     limits emits limit or ulimit commands in the format understood by
	     that shell.  If the name of the shell cannot be determined, then
	     the ulimit format used by sh(1) is used.

	     This is very useful for setting limits used by scripts, or prior
	     launching of daemons and other background tasks with specific
	     resource limit settings, and provides the benefit of allowing
	     global configuration of maximum resource usage by maintaining a
	     central database of settings in the login class database.

	     Within a shell script, limits will normally be used with eval
	     within backticks as follows:

		   eval `limits -e -C daemon`

	     which causes the output of limits to be evaluated and set by the
	     current shell.

     The value of limitflags specified in the above contains one or more of
     the following options:


     -S        Select display or setting of ``soft'' (or current) resource
	       limits.	If specific limits settings follow this switch, only
	       soft limits are affected unless overridden later with either
	       the -H or -B options.

     -H        Select display or setting of ``hard'' (or maximum) resource
	       limits.	If specific limits settings follow this switch, only
	       hard limits are affected until overridden later with either the
	       -S or -B options.

     -B        Select display or setting of both ``soft'' (current) or
	       ``hard'' (maximum) resource limits.  If specific limits set-
	       tings follow this switch, both soft and hard limits are
	       affected until overridden later with either the -S or -H
	       options.  -e Select ``eval mode'' formatting for output.  This
	       is valid only on display mode and cannot be used when running a
	       command.  The exact syntax used for output depends upon the
	       type of shell from which limits is invoked.

     -b [val]  Select or set the sbsize resource limit.

     -c [val]  Select or set (if val is specified) the coredumpsize resource
	       limit.  A value of 0 disables core dumps.

     -d [val]  Select or set (if val is specified) the datasize resource
	       limit.

     -f [val]  Select or set the filesize resource limit.

     -l [val]  Select or set the memorylocked resource limit.

     -m [val]  Select or set the memoryuse size limit.

     -n [val]  Select or set the openfiles resource limit.  The system-wide
	       limit on the maximum number of open files per process can be
	       viewed by examining the kern.maxfilesperproc sysctl(8) vari-
	       able.  The total number of simultaneously open files in the
	       entire system is limited to the value displayed by the
	       kern.maxfiles sysctl(8) variable.

     -s [val]  Select or set the stacksize resource limit.

     -t [val]  Select or set the cputime resource limit.

     -u [val]  Select or set the maxproc resource limit.  The system-wide
	       limit on the maximum number of processes allowed per UID can be
	       viewed by examining the kern.maxprocperuid sysctl(8) variable.
	       The maximum number of processes that can be running simultane-
	       ously in the entire system is limited to the value of the
	       kern.maxproc sysctl(8) variable.

     -v [val]  Select or set the virtualmem resource limit.  This limit encom-
	       passes the entire VM space for the user process and is inclu-
	       sive of text, data, bss, stack, brk(2), sbrk(2) and mmap(2)'d
	       space.

     Valid values for val in the above set of options consist of either the

	   g	 gigabytes.
	   t	 terabytes.

     The cputime resource defaults to a number of seconds, but a multiplier
     may be used, and as with size values, multiple values separated by a
     valid suffix are added together:

	   s	 seconds.
	   m	 minutes.
	   h	 hours.
	   d	 days.
	   w	 weeks.
	   y	 365 day years.

     -E        Cause limits to completely ignore the environment it inherits.

     -a        Force all resource settings to be displayed even if other spe-
	       cific resource settings have been specified.  For example, if
	       you wish to disable core dumps when starting up the Usenet News
	       system, but wish to set all other resource settings as well
	       that apply to the ``news'' account, you might use:

		     eval `limits -U news -aBec 0`

	       As with the setrlimit(2) call, only the superuser may raise
	       process ``hard'' resource limits.  Non-root users may, however,
	       lower them or change ``soft'' resource limits within to any
	       value below the hard limit.  When invoked to execute a program,
	       the failure of limits to raise a hard limit is considered a
	       fatal error.

DIAGNOSTICS

     The limits utility exits with EXIT_FAILURE if usage is incorrect in any
     way; i.e., an invalid option, or set/display options are selected in the
     same invocation, -e is used when running a program, etc.  When run in
     display or eval mode, limits exits with a status of EXIT_SUCCESS.	When
     run in command mode and execution of the command succeeds, the exit sta-
     tus will be whatever the executed program returns.

SEE ALSO

     csh(1), env(1), limit(1), sh(1), getrlimit(2), setrlimit(2),
     login_cap(3), login.conf(5), sysctl(8)

BUGS

     The limits utility does not handle commands with equal (`=') signs in
     their names, for obvious reasons.

     When eval output is selected, the /proc file system must be installed and
     mounted for the shell to be correctly determined, and therefore output
     syntax correct for the running shell.  The default output is valid for
     sh(1), so this means that any usage of limits in eval mode prior mounting
     /proc may only occur in standard bourne shell scripts.

     The limits utility makes no effort to ensure that resource settings emit-
     ted or displayed are valid and settable by the current user.  Only a
     superuser account may raise hard limits, and when doing so the FreeBSD
     kernel will silently lower limits to values less than specified if the
     values given are too high.

SPONSORED LINKS