ulimit(1) 맨 페이지 - 윈디하나의 솔라나라


맨 페이지 이름


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]

       ulimit [-HSacdfmnpstv] [limit]

       ulimit [-SHabcdefilmnpqrstuvxT] [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 can be read). Only  a  process  with  appropriate  privileges  can
       increase 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 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 appropri‐
       ate 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)

       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  privi‐
             leged 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 and  capabilities  of  the  filesystem.  See

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

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

       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 by sysdef are in hexadeci‐
                       mal, 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

       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  tun‐
       ables.  The  only  controls  for  these are hard limits, set in a shell
       startup file, or system-wide soft limits, which, for the  current  ver‐
       sion of the Solaris OS, is 2^13bytes.

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

       Increasing the limit for a resource  usually  requires  special  privi‐
       leges.  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 ksh:

       -a           Displays all current resource limits.

       -b           Specifies the socket buffer size in bytes.

       -c           Specifies the core file size in blocks.

       -d           Specifies the data size in kbytes.

       -f           Specifies the file size in blocks.

       -H           Displays or sets a hard limit.

       -L           Specifies the number of file locks.

       -l           Specifies the locked address space in Kbytes.

       -M           Specifies the address space limit in Kbytes.

       -n           Specifies the number of open files.

       -p           Specifies the pipe buffer size in bytes.

       -m           Specifies the resident set size in Kbytes

       -S           Displays or sets a soft limit.

       -s           Specifies the stack size in Kbytes.

       -T           Specifies the number of threads.

       -t           Specifies the CPU time in seconds.

       -u           Specifies the number of processes.

       -v           Specifies the process size in Kbytes.

       The  bash  ulimit  function uses different units for the core file (-c)
       and file size (-f) limits than other ulimit implementations.  The  bash
       shell  uses  block  size  1024b  while  other  implementations use 512b
       blocks. This has to be taken into account when you write a  code  which
       is  to  be  executed  by  different shells, like /etc/profile. For more
       information about the documentation of bash built-in  function  ulimit,
       see the bash(1) man page.

       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.

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

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

       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

       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

       Example 3 Limiting the Core Dump File Size

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

         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

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

       See  environ(7) for descriptions of the following environment variables
       that affect the execution of ulimit: LANG,  LC_ALL,  LC_CTYPE,  LC_MES‐
       SAGES, and NLSPATH.

       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(7) for descriptions of the following attributes:

   /usr/bin/ulimit, csh, ksh88, sh
       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)

       ATTRIBUTE  TYPEATTRIBUTE VALUE _ Availabilitysystem/core-os _ Interface
       StabilityCommitted _ StandardSee standards(7).

       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i)

       ATTRIBUTE TYPEATTRIBUTE VALUE _ Availabilitysystem/core-os _  Interface

       bc(1),  csh(1),  ksh(1),  ksh88(1), sh(1), getrlimit(2), attributes(7),
       environ(7), standards(7), df(8), su(8), swap(8), sysdef(8)

       Be aware of possible unexpected consequences when using ulimit in  con‐
       junction   with  other  Solaris  resource-limiting  features,  such  as
       prctl(1). See resource-controls(7).

       With the use of the project resource controls  described  in  resource-
       controls(7),  you should use prctl(1) to get an accurate observation of
       the limits in effect at any given time.

Oracle Solaris 11.4               07 Dec 2016                         limit(1)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.