Unix/Linux Go Back    


OpenSolaris 2009.06 - man page for ulimit (opensolaris section 1)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)


limit(1)				  User Commands 				 limit(1)

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

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

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

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

   csh
       limit [-h] [resource [limit]]

       unlimit [-h] [resource]

   ksh
       ulimit [-HSacdfnstv] [limit]

   ksh93
       ulimit [-HSacdfmnpstv] [limit]

DESCRIPTION
   /usr/bin/ulimit
       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 can be read). Only a process with
       appropriate privileges can increase the limit.

   sh
       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 can be
       printed at one time. The -a option prints all limits.

       If limit is present, ulimit  sets  the  specified  limit  tolimit.  The	string	unlimited
       requests  that the current limit, if any, be removed. Any user can set a soft limit to any
       value less than or equal to the hard limit. Any user can lower a hard limit. Only  a  user
       with appropriate privileges can raise or remove a hard limit. See getrlimit(2).

       The  -H	option	specifies  a hard limit. The -S option specifies a soft limit. If neither
       option is specified, ulimit sets both limits and prints 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)

   csh
       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. The  string  unlim-
       ited  requests that the current limit, if any, be removed. If limit is omitted, prints the
       current limit. If resource is omitted, displays all limits.

       -h    Use hard limits instead of the current limits. Hard limits impose a ceiling  on  the
	     values of the current limits. Only the privileged user can raise the hard limits.

       resource is one of:

       cputime	       Maximum CPU seconds per process.

       filesize        Largest	single	file  allowed. Limited to the size of the filesystem (see
		       df(1M)).

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

       stacksize       Maximum stack size for the process. The default stack size is 2^64.

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

       descriptors     Maximum	number	of file descriptors. Run the sysdef(1M) command to obtain
		       the maximum possible limits for your system. The values	reported  are  in
		       hexadecimal,  but  can  be translated into decimal numbers using the bc(1)
		       command.

       memorysize      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 can do this.

   ksh
       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 lim-
       its. The limit for a specified resource is set when limit is specified. The value of limit
       can  be	a  number in the unit specified below with each resource, or the value unlimited.
       The string unlimited requests that the current limit, if any, be removed. The  -H  and  -S
       flags  specify whether the hard limit or the soft limit for the specified 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 specified. 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
	     can 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 specified, -f is assumed.

   Per-Shell Memory Parameters
       The  heapsize,  datasize,  and stacksize parameters are not system tunables. The only con-
       trols for these are hard limits, set in a shell startup file, or system-wide soft  limits,
       which, for the current version of the Solaris OS, is 2^64bytes.

   ksh93
       ulimit  sets or displays resource limits. These limits apply to the current process and to
       each child process created after the resource limit has been set. If limit  is  specified,
       the resource limit is set, otherwise, its current value is displayed on standard output.

       Increasing  the	limit  for  a  resource usually requires special privileges. Some systems
       allow you to lower resource limits and later increase them. These are called soft  limits.
       Once a hard limit is set the resource cannot be increased.

       Different  systems allow you to specify different resources and some restrict how much you
       can raise the limit of the resource.

       The value of limit depends on the unit of the resource listed for each resource. In  addi-
       tion, limit can be "unlimited" to indicate no limit for that resource.

       If  you	do  not  specify -H or -S, -S is used for listing and both -S and -H are used for
       setting resources.

       If you do not specify any resource, the default is -f.

       The following options are available for ulimit in ksh93:

       -a	    Displays all current resource limits.

       -b	    Specifies the socket buffer size in bytes.
       --sbsize

       -c	    Specifies the core file size in blocks.
       --core

       -d	    Specifies the data size in kbytes.
       --data

       -f	    Specifies the file size in blocks.
       --fsize

       -H	    Displays or sets a hard limit.

       -L	    Specifies the number of file locks.
       --locks

       -l	    Specifies the locked address space in Kbytes.
       --memlock

       -M	    Specifies the address space limit in Kbytes.
       --as

       -n	    Specifies the number of open files.
       --nofile

       -p	    Specifies the pipe buffer size in bytes.
       --pipe

       -m	    Specifies the resident set size in Kbytes
       --rss

       -S	    Displays or sets a soft limit.

       -s	    Specifies the stack size in Kbytes.
       --stack

       -T	    Specifies the number of threads.
       --threads

       -t	    Specifies the CPU time in seconds.
       --cpu

       -u	    Specifies the number of processes.
       --nproc

       -v	    Specifies the process size in Kbytes.
       --vmem

OPTIONS
       The following option is supported by /usr/bin/ulimit:

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

OPERANDS
       The following operand is supported by /usr/bin/ulimit:

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

EXAMPLES
   /usr/bin/ulimit
       Example 1 Limiting the Stack Size

       The following example limits the stack size to 512 kilobytes:

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

   sh/ksh
       Example 2 Limiting the Number of File Descriptors

       The following command limits the number of file descriptors to 12:

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

   csh
       Example 3 Limiting the Core Dump File Size

       The following command limits the size of a core dump file size to 0 kilobytes:

	 example% limit coredumpsize 0
	 example% 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

       The following command removes the above limitation for the core file size:

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

ENVIRONMENT VARIABLES
       See  environ(5)	for  descriptions  of the following environment variables that affect the
       execution of ulimit: LANG, LC_ALL, LC_CTYPE, LC_MESSAGES, and NLSPATH.

EXIT STATUS
       The following exit values are returned by ulimit:

       0     Successful completion.

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

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

   /usr/bin/ulimit, csh, ksh, sh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Committed 		   |
       +-----------------------------+-----------------------------+
       |Standard		     |See standards(5). 	   |
       +-----------------------------+-----------------------------+

   ksh93
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Uncommitted		   |
       +-----------------------------+-----------------------------+

SEE ALSO
       bc(1), csh(1), ksh(1),  ksh93(1),  sh(1),  df(1M),  su(1M),  swap(1M),  sysdef(1M),  getr-
       limit(2), attributes(5), environ(5), standards(5)

SunOS 5.11				    2 Nov 2007					 limit(1)
Unix & Linux Commands & Man Pages : ©2000 - 2017 Unix and Linux Forums


All times are GMT -4. The time now is 11:38 AM.