Tribblix: manual page: limit.1

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 to limit. 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 unlimited 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(8)).

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(8)
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 limits. 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 controls 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 addition, 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
--sbsize
Specifies the socket buffer size in bytes.

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

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

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

-H
Displays or sets a hard limit.

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

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

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

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

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

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

-S
Displays or sets a soft limit.

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

-T
--threads
Specifies the number of threads.

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

-u
--nproc
Specifies the number of processes.

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

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(7) 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