# mkfifo

## NAME



           mkfifo, mkfifoat - make a FIFO special file (a named pipe)
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



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


## DESCRIPTION



           **mkfifo**() makes a FIFO special file with name _path_.  _mode_ specifies
           the FIFO's permissions.  It is modified by the process's **umask** in
           the usual way: the permissions of the created file are
           _(mode & ~umask)_.
    
           A FIFO special file is similar to a pipe, except that it is
           created in a different way.  Instead of being an anonymous
           communications channel, a FIFO special file is entered into the
           filesystem by calling **mkfifo**().
    
           Once you have created a FIFO special file in this way, any process
           can open it for reading or writing, in the same way as an ordinary
           file.  However, it has to be open at both ends simultaneously
           before you can proceed to do any input or output operations on it.
           Opening a FIFO for reading normally blocks until some other
           process opens the same FIFO for writing, and vice versa.  See
           fifo(7) for nonblocking handling of FIFO special files.
    
       **mkfifoat()**
           The **mkfifoat**() function operates in exactly the same way as
           **mkfifo**(), 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 **mkfifo**() 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 **mkfifo**()).
    
           If _path_ is absolute, then _dirfd_ is ignored.
    
           See openat(2) for an explanation of the need for **mkfifoat**().
    


## RETURN VALUE



           On success **mkfifo**() and **mkfifoat**() return 0.  On error, -1 is
           returned and _errno_ is set to indicate the error.
    


## ERRORS



           **EACCES** One of the directories in _path_ did not allow search
                  (execute) permission.
    
           **EBADF**(**mkfifoat**()) _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.  This includes the case where _path_ is
                  a symbolic link, dangling or not.
    
           **ENAMETOOLONG**
                  Either the total size of _path_ is greater than **PATH_MAX** , or
                  an individual filename component has a length greater than
                  **NAME_MAX**.  In the GNU system, there is no imposed limit on
                  overall filename length, but some filesystems may place
                  limits on the length of a component.
    
           **ENOENT** A directory component in _path_ does not exist or is a
                  dangling symbolic link.
    
           **ENOSPC** The directory or filesystem has no room for the new file.
    
           **ENOTDIR**
                  A component used as a directory in _path_ is not, in fact, a
                  directory.
    
           **ENOTDIR**
                  (**mkfifoat**()) _path_ is relative and _dirfd_ is a file
                  descriptor referring to a file other than a directory.
    
           **EROFS** _path_ refers to a read-only filesystem.
    


## ATTRIBUTES



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


## VERSIONS



           It is implemented using mknodat(2).
    


## STANDARDS



           POSIX.1-2008.
    


* * *