# mlockall

## 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



           mlockall, munlockall — lock/unlock the address space of a process
           (**REALTIME**)
    


## SYNOPSIS



           #include <sys/mman.h>
    
           int mlockall(int _flags_);
           int munlockall(void);
    


## DESCRIPTION



           The _mlockall_() function shall cause all of the pages mapped by the
           address space of a process to be memory-resident until unlocked or
           until the process exits or _exec_ s another process image. The _flags_
           argument determines whether the pages to be locked are those
           currently mapped by the address space of the process, those that
           are mapped in the future, or both. The _flags_ argument is
           constructed from the bitwise-inclusive OR of one or more of the
           following symbolic constants, defined in _< sys/mman.h>_:
    
           MCL_CURRENT Lock all of the pages currently mapped into the
                       address space of the process.
    
           MCL_FUTURE  Lock all of the pages that become mapped into the
                       address space of the process in the future, when those
                       mappings are established.
    
           If MCL_FUTURE is specified, and the automatic locking of future
           mappings eventually causes the amount of locked memory to exceed
           the amount of available physical memory or any other
           implementation-defined limit, the behavior is implementation-
           defined. The manner in which the implementation informs the
           application of these situations is also implementation-defined.
    
           The _munlockall_() function shall unlock all currently mapped pages
           of the address space of the process. Any pages that become mapped
           into the address space of the process after a call to _munlockall_()
           shall not be locked, unless there is an intervening call to
           _mlockall_() specifying MCL_FUTURE or a subsequent call to
           _mlockall_() specifying MCL_CURRENT. If pages mapped into the
           address space of the process are also mapped into the address
           spaces of other processes and are locked by those processes, the
           locks established by the other processes shall be unaffected by a
           call by this process to _munlockall_().
    
           Upon successful return from the _mlockall_() function that specifies
           MCL_CURRENT, all currently mapped pages of the address space of
           the process shall be memory-resident and locked.  Upon return from
           the _munlockall_() function, all currently mapped pages of the
           address space of the process shall be unlocked with respect to the
           address space of the process.  The memory residency of unlocked
           pages is unspecified.
    
           Appropriate privileges are required to lock process memory with
           _mlockall_().
    


## RETURN VALUE



           Upon successful completion, the _mlockall_() function shall return a
           value of zero. Otherwise, no additional memory shall be locked,
           and the function shall return a value of -1 and set _errno_ to
           indicate the error. The effect of failure of _mlockall_() on
           previously existing locks in the address space is unspecified.
    
           If it is supported by the implementation, the _munlockall_()
           function shall always return a value of zero. Otherwise, the
           function shall return a value of -1 and set _errno_ to indicate the
           error.
    


## ERRORS



           The _mlockall_() function shall fail if:
    
           **EAGAIN** Some or all of the memory identified by the operation could
                  not be locked when the call was made.
    
           **EINVAL** The _flags_ argument is zero, or includes unimplemented
                  flags.
    
           The _mlockall_() function may fail if:
    
           **ENOMEM** Locking all of the pages currently mapped into the address
                  space of the process would exceed an implementation-defined
                  limit on the amount of memory that the process may lock.
    
           **EPERM** The calling process does not have appropriate privileges to
                  perform the requested operation.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *