# posix_memalign

## NAME



           posix_memalign, aligned_alloc, memalign, valloc, pvalloc -
           allocate aligned memory
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <stdlib.h>**
    
           **int posix_memalign(void ****_memptr_**, size_t** _alignment_**, size_t** _size_**);**
           **void *aligned_alloc(size_t** _alignment_**, size_t** _size_**);**
           **[[deprecated]] void *valloc(size_t** _size_**);**
    
           **#include <malloc.h>**
    
           **[[deprecated]] void *memalign(size_t** _alignment_**, size_t** _size_**);**
           **[[deprecated]] void *pvalloc(size_t** _size_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **posix_memalign**():
               _POSIX_C_SOURCE >= 200112L
    
           **aligned_alloc**():
               _ISOC11_SOURCE
    
           **valloc**():
               Since glibc 2.12:
                   (_XOPEN_SOURCE >= 500) && !(_POSIX_C_SOURCE >= 200112L)
                       || /* glibc >= 2.19: */ _DEFAULT_SOURCE
                       || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE
               Before glibc 2.12:
                   _BSD_SOURCE || _XOPEN_SOURCE >= 500
    


## DESCRIPTION



           **posix_memalign**() allocates _size_ bytes and places the address of
           the allocated memory in _*memptr_.  The address of the allocated
           memory will be a multiple of _alignment_ , which must be a power of
           two and a multiple of _sizeof(void *)_.  This address can later be
           successfully passed to free(3).  If _size_ is 0, then the value
           placed in _*memptr_ is either NULL or a unique pointer value.
    
           The obsolete function **memalign**() allocates _size_ bytes and returns
           a pointer to the allocated memory.  The memory address will be a
           multiple of _alignment_ , which must be a power of two.
    
           **aligned_alloc**() is the same as **memalign**(), except for the added
           restriction that _alignment_ must be a power of two.
    
           The obsolete function **valloc**() allocates _size_ bytes and returns a
           pointer to the allocated memory.  The memory address will be a
           multiple of the page size.  It is equivalent to
           _memalign(sysconf(_SC_PAGESIZE),size)_.
    
           The obsolete function **pvalloc**() is similar to **valloc**(), but rounds
           the size of the allocation up to the next multiple of the system
           page size.
    
           For all of these functions, the memory is not zeroed.
    


## RETURN VALUE



           **aligned_alloc**(), **memalign**(), **valloc**(), and **pvalloc**() return a
           pointer to the allocated memory on success.  On error, NULL is
           returned, and _errno_ is set to indicate the error.
    
           **posix_memalign**() returns zero on success, or one of the error
           values listed in the next section on failure.  The value of _errno_
           is not set.  On Linux (and other systems), **posix_memalign**() does
           not modify _memptr_ on failure.  A requirement standardizing this
           behavior was added in POSIX.1-2008 TC2.
    


## ERRORS



           **EINVAL** The _alignment_ argument was not a power of two, or was not a
                  multiple of _sizeof(void *)_.
    
           **ENOMEM** Out of memory.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌───────────────────────────────┬───────────────┬────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├───────────────────────────────┼───────────────┼────────────────┤
           │ **aligned_alloc**(), **memalign**(),  │ Thread safety │ MT-Safe        │
           │ **posix_memalign**()              │               │                │
           ├───────────────────────────────┼───────────────┼────────────────┤
           │ **valloc**(), **pvalloc**()           │ Thread safety │ MT-Unsafe init │
           └───────────────────────────────┴───────────────┴────────────────┘
    


## STANDARDS



           **aligned_alloc**()
                  C11.
    
           **posix_memalign**()
                  POSIX.1-2008.
    
           **memalign**()
           **valloc**()
                  None.
    
           **pvalloc**()
                  GNU.
    


## NOTES



           On many systems there are alignment restrictions, for example, on
           buffers used for direct block device I/O.  POSIX specifies the
           _pathconf(path,_PC_REC_XFER_ALIGN)_ call that tells what alignment
           is needed.  Now one can use **posix_memalign**() to satisfy this
           requirement.
    
           **posix_memalign**() verifies that _alignment_ matches the requirements
           detailed above.  **memalign**() may not check that the _alignment_
           argument is correct.
    
           POSIX requires that memory obtained from **posix_memalign**() can be
           freed using free(3).  Some systems provide no way to reclaim
           memory allocated with **memalign**() or **valloc**() (because one can pass
           to free(3) only a pointer obtained from malloc(3), while, for
           example, **memalign**() would call malloc(3) and then align the
           obtained value).  The glibc implementation allows memory obtained
           from any of these functions to be reclaimed with free(3).
    
           The glibc malloc(3) always returns 8-byte aligned memory
           addresses, so these functions are needed only if you require
           larger alignment values.
    


* * *