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

FreeBSD Manual Pages


home | help
limit(1)			 User Commands			      limit(1)

       limit, ulimit, unlimit -	set or get limitations on the system resources
       available to the	current	shell and its descendents

       /usr/bin/ulimit [-f] [blocks]

       ulimit [	- [HS] [ a | cdfnstv]]

       ulimit [	- [HS] [ c | d | f | n | s | t | v]] limit

       limit [-h] [ resource [limit]]

       unlimit [-h] [resource]

       ulimit [-HSacdfnstv] [limit]

       The ulimit utility sets or reports the file-size	writing	limit  imposed
       on  files  written  by  the shell and its child processes (files	of any
       size may	be read). Only a process with appropriate privileges  can  in-
       crease the limit.

       The Bourne shell	built-in function, ulimit, prints or sets hard or soft
       resource	limits.	These limits are described in getrlimit(2).

       If limit	is not present,	ulimit prints the specified limits. Any	number
       of limits may be	printed	at one time. The -a option prints all limits.

       If  limit  is  present,	ulimit	sets the specified limit to limit. The
       string unlimited	requests the largest valid limit. Limits  may  be  set
       for  only  one resource at a time. Any user may set a soft limit	to any
       value below the hard limit. Any user may	lower a	hard limit. Only a su-
       per-user	may raise a hard limit;	see su(1M).

       The  -H	option	specifies a hard limit.	The -S option specifies	a soft
       limit. If neither option	is specified, ulimit will set both limits  and
       print the soft limit.

       The  following  options	specify	 the  resource	whose limits are to be
       printed or set. If no option is	specified,  the	 file  size  limit  is
       printed or set.

       -c    maximum core file size (in	512-byte blocks)

       -d    maximum size of data segment or heap (in kbytes)

       -f    maximum file size (in 512-byte blocks)

       -n    maximum file descriptor plus 1

       -s    maximum size of stack segment (in kbytes)

       -t    maximum CPU time (in seconds)

       -v    maximum size of virtual memory (in	kbytes)

       The  C-shell  built-in  function,  limit, limits	the consumption	by the
       current process or any process it spawns, each not to exceed  limit  on
       the  specified  resource. If limit is omitted, print the	current	limit;
       if resource is omitted, display all limits. (Run	the sysdef(1M) command
       to  obtain the maximum possible limits for your system.	The values re-
       ported are in hexadecimal, but can be translated	into  decimal  numbers
       using the bc(1) command).

       -h    Use hard limits instead of	the current limits. Hard limits	impose
	     a ceiling on the values of	the current limits.  Only  the	privi-
	     leged user	may raise the hard limits.

       resource	is one of:

	     Maximum CPU seconds per process.

	     Largest  single file allowed; limited to the size of the filesys-
	     tem (see df(1M)).

	     The maximum size of a process's heap in kilobytes.

	     Maximum stack size	for the	process	(see swap(1M)).

	     Maximum size of a core dump (file). This is limited to  the  size
	     of	the filesystem.

	     Maximum number of file descriptors	(run sysdef()).

	     Maximum size of virtual memory.

       limit is	a number, with an optional scaling factor, as follows:

       nh    Hours (for	cputime).

       nk    n kilobytes. This is the default for all but cputime.

       nm    n megabytes or minutes (for cputime).

       mm:ss Minutes and seconds (for cputime).

       unlimit	removes	a limitation on	resource. If no	resource is specified,
       then all	resource limitations are removed. See the description  of  the
       limit command for the list of resource names.

       -h    Remove corresponding hard limits. Only the	privileged user	may do

       The Korn	shell built-in function, ulimit, sets or displays  a  resource
       limit. The available resources limits are listed	below. Many systems do
       not contain one or more of these	limits.	 The limit for a specified re-
       source is set when limit	is specified. The value	of limit can be	a num-
       ber in the unit specified below with each resource, or the value	unlim-
       ited.  The  -H  and -S flags specify whether the	hard limit or the soft
       limit for the given resource is set. A hard limit cannot	 be  increased
       once  it	 is  set. A soft limit can be increased	up to the value	of the
       hard limit.  If neither the -H or -S options is	specified,  the	 limit
       applies	to  both.  The current resource	limit is printed when limit is
       omitted.	In this	case, the soft limit is	printed	unless	-H  is	speci-
       fied. When more than one	resource is specified, then the	limit name and
       unit is printed before the value.

       -a    Lists all of the current resource limits.

       -c    The number	of 512-byte blocks on the size of core dumps.

       -d    The number	of K-bytes on the size of the data area.

       -f    The number	of 512-byte blocks on files written by child processes
	     (files of any size	may be read).

       -n    The number	of file	descriptors plus 1.

       -s    The number	of K-bytes on the size of the stack area.

       -t    The number	of seconds (CPU	time) to be used by each process.

       -v    The number	of K-bytes for virtual memory.

       If no option is given, -f is assumed.

       The following option is supported by ulimit:

       -f    Set  (or  report, if no blocks operand is present), the file size
	     limit in blocks. The -f option is also the	default	case.

       The following operand is	supported by ulimit:

	     The number	of 512-byte blocks to use as the new file size limit.

       Example 1:  Limiting the	stack size

       To limit	the stack size to 512 kilobytes:

       % ulimit	-s 512
       % ulimit	-a
       % time(seconds)	       unlimited
       file(blocks)	       100
       data(kbytes)	       523256
       stack(kbytes)	       512
       coredump(blocks)	       200
       nofiles(descriptors)    64
       memory(kbytes)	       unlimited

       Example 2:  Limiting the	number of file descriptors

       To limit	the number of file descriptors to 12:

       $ ulimit	-n 12
       $ ulimit	-a
       time(seconds)		unlimited
       file(blocks)		41943
       data(kbytes)		523256
       stack(kbytes)		8192
       coredump(blocks)		200
       nofiles(descriptors)	12
       vmemory(kbytes)		unlimited

       Example 3: Limiting the core dump file size

       To limit	the size of a core dump	file size to 0 kilobytes:

       % limit coredumpsize 0
       % limit
       cputime		       unlimited
       filesize		       unlimited
       datasize		       523256 kbytes
       stacksize	       8192 kbytes
       coredumpsize	       0 kbytes
       descriptors	       64
       memorysize	       unlimited

       Example 4: Removing the limitation for core file	size

       To remove the above limitation for the core file	size:

       % unlimit coredumpsize
       % limit
       cputime		       unlimited
       filesize		       unlimited
       datasize		       523256 kbytes
       stacksize	       8192 kbytes
       coredumpsize	       unlimited
       descriptors	       64
       memorysize	       unlimited

       See environ(5) for descriptions of the following	environment  variables
       that  affect  the  execution  of	 ulimit:  LC_CTYPE,  LC_MESSAGES,  and

       The following exit values are returned by ulimit:

       0     Successful	completion.

       >0    A request for a higher limit was rejected or an error occurred.

       See attributes(5) for descriptions of the following attributes:

       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       |Availability		     |SUNWcsu			   |

       bc(1), csh(1), ksh(1), sh(1),  df(1M),  su(1M),	swap(1M),  sysdef(1M),
       getrlimit(2), attributes(5), environ(5)

SunOS 5.9			  26 Jun 1998			      limit(1)


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

home | help