# ulimit

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           ulimit — get and set process limits
    


## SYNOPSIS



           #include <ulimit.h>
    
           long ulimit(int _cmd_ , ...);
    


## DESCRIPTION



           The _ulimit_() function shall control process limits. The process
           limits that can be controlled by this function include the maximum
           size of a single file that can be written (this is equivalent to
           using _setrlimit_() with RLIMIT_FSIZE). The _cmd_ values, defined in
           _< ulimit.h>_, include:
    
           UL_GETFSIZE Return the file size limit (RLIMIT_FSIZE) of the
                       process. The limit shall be in units of 512-byte
                       blocks and shall be inherited by child processes.
                       Files of any size can be read. The return value shall
                       be the integer part of the soft file size limit
                       divided by 512. If the result cannot be represented as
                       a **long** , the result is unspecified.
    
           UL_SETFSIZE Set the file size limit for output operations of the
                       process to the value of the second argument, taken as
                       a **long** , multiplied by 512. If the result would
                       overflow an **rlim_t** , the actual value set is
                       unspecified. Any process may decrease its own limit,
                       but only a process with appropriate privileges may
                       increase the limit. The return value shall be the
                       integer part of the new file size limit divided by
                       512.
    
           The _ulimit_() function shall not change the setting of _errno_ if
           successful.
    
           As all return values are permissible in a successful situation, an
           application wishing to check for error situations should set _errno_
           to 0, then call _ulimit_(), and, if it returns -1, check to see if
           _errno_ is non-zero.
    


## RETURN VALUE



           Upon successful completion, _ulimit_() shall return the value of the
           requested limit. Otherwise, -1 shall be returned and _errno_ set to
           indicate the error.
    


## ERRORS



           The _ulimit_() function shall fail and the limit shall be unchanged
           if:
    
           **EINVAL** The _cmd_ argument is not valid.
    
           **EPERM** A process not having appropriate privileges attempts to
                  increase its file size limit.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           Since the _ulimit_() function uses type **long** rather than **rlim_t** ,
           this function is not sufficient for file sizes on many current
           systems.  Applications should use the _getrlimit_() or _setrlimit_()
           functions instead of the obsolescent _ulimit_() function.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           The _ulimit_() function may be removed in a future version.
    


* * *