# mkdir

## NAME



           mkdir, mkdirat - create a directory
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <sys/stat.h>**
    
           **int mkdir(const char ***_path_**, mode_t** _mode_**);**
    
           **#include <fcntl.h>           **/* Definition of AT_* constants */
           **#include <sys/stat.h>**
    
           **int mkdirat(int** _dirfd_**, const char ***_path_**, mode_t** _mode_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **mkdirat**():
               Since glibc 2.10:
                   _POSIX_C_SOURCE >= 200809L
               Before glibc 2.10:
                   _ATFILE_SOURCE
    


## DESCRIPTION



           **mkdir**() attempts to create a directory named _path_.
    
           The argument _mode_ specifies the mode for the new directory (see
           inode(7)).  It is modified by the process's _umask_ in the usual
           way: in the absence of a default ACL, the mode of the created
           directory is (_mode_ & ~_umask_ & 0777).  Whether other _mode_ bits are
           honored for the created directory depends on the operating system.
           For Linux, see VERSIONS below.
    
           The newly created directory will be owned by the effective user ID
           of the process.  If the directory containing the file has the set-
           group-ID bit set, or if the filesystem is mounted with BSD group
           semantics (_mount -o bsdgroups_ or, synonymously _mount -o grpid_),
           the new directory will inherit the group ownership from its
           parent; otherwise it will be owned by the effective group ID of
           the process.
    
           If the parent directory has the set-group-ID bit set, then so will
           the newly created directory.
    
       **mkdirat()**
           The **mkdirat**() system call operates in exactly the same way as
           **mkdir**(), except for the differences described here.
    
           If _path_ is relative, then it is interpreted relative to the
           directory referred to by the file descriptor _dirfd_ (rather than
           relative to the current working directory of the calling process,
           as is done by **mkdir**() for a relative pathname).
    
           If _path_ is relative and _dirfd_ is the special value **AT_FDCWD** , then
           _path_ is interpreted relative to the current working directory of
           the calling process (like **mkdir**()).
    
           If _path_ is absolute, then _dirfd_ is ignored.
    
           See openat(2) for an explanation of the need for **mkdirat**().
    


## RETURN VALUE



           **mkdir**() and **mkdirat**() return zero on success.  On error, -1 is
           returned and _errno_ is set to indicate the error.
    


## ERRORS



           **EACCES** The parent directory does not allow write permission to the
                  process, or one of the directories in _path_ did not allow
                  search permission.  (See also path_resolution(7).)
    
           **EBADF**(**mkdirat**()) _path_ is relative but _dirfd_ is neither **AT_FDCWD**
                  nor a valid file descriptor.
    
           **EDQUOT** The user's quota of disk blocks or inodes on the filesystem
                  has been exhausted.
    
           **EEXIST** _path_ already exists (not necessarily as a directory).  This
                  includes the case where _path_ is a symbolic link, dangling
                  or not.
    
           **EFAULT** _path_ points outside your accessible address space.
    
           **EINVAL** The final component ("basename") of the new directory's
                  _path_ is invalid (e.g., it contains characters not permitted
                  by the underlying filesystem).
    
           **ELOOP** Too many symbolic links were encountered in resolving _path_.
    
           **EMLINK** The number of links to the parent directory would exceed
                  **LINK_MAX**.
    
           **ENAMETOOLONG**
                  _path_ was too long.
    
           **ENOENT** A directory component in _path_ does not exist or is a
                  dangling symbolic link.
    
           **ENOMEM** Insufficient kernel memory was available.
    
           **ENOSPC** The device containing _path_ has no room for the new
                  directory.
    
           **ENOSPC** The new directory cannot be created because the user's disk
                  quota is exhausted.
    
           **ENOTDIR**
                  A component used as a directory in _path_ is not, in fact, a
                  directory.
    
           **ENOTDIR**
                  (**mkdirat**()) _path_ is relative and _dirfd_ is a file descriptor
                  referring to a file other than a directory.
    
           **EPERM** The filesystem containing _path_ does not support the
                  creation of directories.
    
           **EROFS** _path_ refers to a file on a read-only filesystem.
    
           **EOVERFLOW**
                  UID or GID mappings (see user_namespaces(7)) have not been
                  configured.
    


## VERSIONS



           Under Linux, apart from the permission bits, the **S_ISVTX** _mode_ bit
           is also honored.
    
       **glibc notes**
           On older kernels where **mkdirat**() is unavailable, the glibc wrapper
           function falls back to the use of **mkdir**().  When _path_ is relative,
           glibc constructs a pathname based on the symbolic link in
           _/proc/self/fd_ that corresponds to the _dirfd_ argument.
    


## STANDARDS



           POSIX.1-2008.
    


## NOTES



           There are many infelicities in the protocol underlying NFS.  Some
           of these affect **mkdir**().
    


* * *