Provided by: manpages-dev_4.04-2_all bug


       memfd_create - create an anonymous file


       #include <sys/memfd.h>

       int memfd_create(const char *name, unsigned int flags);


       memfd_create()  creates an anonymous file and returns a file descriptor
       that refers to it.  The file behaves like a regular file, and so can be
       modified,  truncated,  memory-mapped,  and  so  on.   However, unlike a
       regular file, it lives in RAM and has a volatile backing storage.  Once
       all  references  to the file are dropped, it is automatically released.
       Anonymous memory is used for all backing pages of the file.  Therefore,
       files  created  by  memfd_create()  have  the  same  semantics as other
       anonymous memory allocations such as those allocated using mmap(2) with
       the MAP_ANONYMOUS flag.

       The initial size of the file is set to 0.  Following the call, the file
       size should be set using ftruncate(2).  (Alternatively, the file may be
       populated by calls to write(2) or similar.)

       The  name  supplied in name is used as a filename and will be displayed
       as the target of the  corresponding  symbolic  link  in  the  directory
       /proc/self/fd/.   The displayed name is always prefixed with memfd: and
       serves only for debugging purposes.  Names do not affect  the  behavior
       of  the  file  descriptor, and as such multiple files can have the same
       name without any side effects.

       The following values may  be  bitwise  ORed  in  flags  to  change  the
       behavior of memfd_create():

              Set   the  close-on-exec  (FD_CLOEXEC)  flag  on  the  new  file
              descriptor.  See  the  description  of  the  O_CLOEXEC  flag  in
              open(2) for reasons why this may be useful.

              Allow  sealing  operations  on this file.  See the discussion of
              the F_ADD_SEALS and F_GET_SEALS operations in fcntl(2), and also
              NOTES,  below.  The initial set of seals is empty.  If this flag
              is not set, the  initial  set  of  seals  will  be  F_SEAL_SEAL,
              meaning that no other seals can be set on the file.

       Unused bits in flags must be 0.

       As  its return value, memfd_create() returns a new file descriptor that
       can be used to refer to the file.  This file descriptor is  opened  for
       both  reading  and  writing  (O_RDWR)  and  O_LARGEFILE  is set for the

       With respect to fork(2) and execve(2), the usual  semantics  apply  for
       the  file  descriptor  created  by  memfd_create().  A copy of the file
       descriptor is inherited by the child produced by fork(2) and refers  to
       the  same  file.   The  file  descriptor is preserved across execve(2),
       unless the close-on-exec flag has been set.


       On success, memfd_create() returns a new file descriptor.  On error, -1
       is returned and errno is set to indicate the error.


       EFAULT The address in name points to invalid memory.

       EINVAL An  unsupported  value  was  specified  in one of the arguments:
              flags included unknown bits, or name was too long.

       EMFILE The per-process limit on the number of open file descriptors has
              been reached.

       ENFILE The system-wide limit on the total number of open files has been

       ENOMEM There was insufficient memory to create a new anonymous file.


       The memfd_create() system call first appeared in Linux  3.17.   Support
       in the GNU C library is pending.


       The memfd_create() system call is Linux-specific.


       The  memfd_create()  system  call  provides  a  simple  alternative  to
       manually mounting a tmpfs filesystem and creating and opening a file in
       that  filesystem.   The  primary purpose of memfd_create() is to create
       files and associated file descriptors that  are  used  with  the  file-
       sealing APIs provided by fcntl(2).

       The  memfd_create()  system  call  also  has  uses without file sealing
       (which is why file-sealing is  disabled,  unless  explicitly  requested
       with  the MFD_ALLOW_SEALING flag).  In particular, it can be used as an
       alternative to creating files in tmp or as an alternative to using  the
       open(2) O_TMPFILE in cases where there is no intention to actually link
       the resulting file into the filesystem.

   File sealing
       In the absence of file sealing, processes that communicate  via  shared
       memory  must either trust each other, or take measures to deal with the
       possibility that an untrusted peer may  manipulate  the  shared  memory
       region  in  problematic  ways.   For  example,  an untrusted peer might
       modify the contents of the shared memory at any  time,  or  shrink  the
       shared  memory region.  The former possibility leaves the local process
       vulnerable to time-of-check-to-time-of-use race  conditions  (typically
       dealt  with  by  copying  data  from  the  shared  memory region before
       checking and using  it).   The  latter  possibility  leaves  the  local
       process  vulnerable to SIGBUS signals when an attempt is made to access
       a now-nonexistent location in the shared memory region.  (Dealing  with
       this  possibility  necessitates  the  use  of  a handler for the SIGBUS

       Dealing with untrusted peers imposes  extra  complexity  on  code  that
       employs shared memory.  Memory sealing enables that extra complexity to
       be eliminated, by allowing a process to operate secure in the knowledge
       that its peer can't modify the shared memory in an undesired fashion.

       An example of the usage of the sealing mechanism is as follows:

       1. The  first  process  creates a tmpfs file using memfd_create().  The
          call yields a file descriptor used in subsequent steps.

       2. The first process sizes the file created in the previous step  using
          ftruncate(2), maps it using mmap(2), and populates the shared memory
          with the desired data.

       3. The first process uses the fcntl(2) F_ADD_SEALS operation  to  place
          one  or  more  seals  on  the  file,  in  order  to restrict further
          modifications on the file.  (If placing the seal F_SEAL_WRITE,  then
          it  will  be  necessary  to  first unmap the shared writable mapping
          created in the previous step.)

       4. A second process obtains a file descriptor for the  tmpfs  file  and
          maps it.  Among the possible ways in which this could happen are the

          *  The  process  that  called  memfd_create()  could  transfer   the
             resulting file descriptor to the second process via a UNIX domain
             socket (see unix(7) and cmsg(3)).  The second process  then  maps
             the file using mmap(2).

          *  The  second process is created via fork(2) and thus automatically
             inherits the file descriptor and mapping.   (Note  that  in  this
             case  and the next, there is a natural trust relationship between
             the two processes, since they are running under the same user ID.
             Therefore, file sealing would not normally be necessary.)

          *  The second process opens the file /proc/<pd>/fd/<fd>, where <pid>
             is  the  PID  of  the  first  process  (the   one   that   called
             memfd_create()),  and  <fd>  is the number of the file descriptor
             returned by the call to  memfd_create()  in  that  process.   The
             second process then maps the file using mmap(2).

       5. The  second  process  uses  the  fcntl(2)  F_GET_SEALS  operation to
          retrieve the bit mask of seals that has been applied  to  the  file.
          This  bit  mask can be inspected in order to determine what kinds of
          restrictions have been placed on file  modifications.   If  desired,
          the  second  process  can  apply  further seals to impose additional
          restrictions (so long as the  F_SEAL_SEAL  seal  has  not  yet  been


       Below  are  shown  two  example  programs  that  demonstrate the use of
       memfd_create() and the file sealing API.

       The  first  program,  t_memfd_create.c,  creates  a  tmpfs  file  using
       memfd_create(),  sets  a  size  for  the file, maps it into memory, and
       optionally places some seals on the file.  The program  accepts  up  to
       three command-line arguments, of which the first two are required.  The
       first argument is the name to  associate  with  the  file,  the  second
       argument  is the size to be set for the file, and the optional third is
       a string of characters that specify seals to be set on file.

       The second program, t_get_seals.c, can be used to open an existing file
       that  was  created via memfd_create() and inspect the set of seals that
       have been applied to that file.

       The following shell session demonstrates the  use  of  these  programs.
       First we create a tmpfs file and set some seals on it:

           $ ./t_memfd_create my_memfd_file 4096 sw &
           [1] 11775
           PID: 11775; fd: 3; /proc/11775/fd/3

       At  this  point,  the  t_memfd_create  program  continues to run in the
       background.  From another program, we can obtain a file descriptor  for
       the  file  created  by  memfd_create() by opening the /proc/PID/fd file
       that corresponds to the descriptor  opened  by  memfd_create().   Using
       that  pathname,  we  inspect  the  content of the /proc/PID/fd symbolic
       link, and use our t_get_seals program to view the seals that have  been
       placed on the file:

           $ readlink /proc/11775/fd/3
           /memfd:my_memfd_file (deleted)
           $ ./t_get_seals /proc/11775/fd/3
           Existing seals: WRITE SHRINK

   Program source: t_memfd_create.c

       #include <sys/memfd.h>
       #include <fcntl.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <string.h>
       #include <stdio.h>

       #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                               } while (0)

       main(int argc, char *argv[])
           int fd;
           unsigned int seals;
           char *addr;
           char *name, *seals_arg;
           ssize_t len;

           if (argc < 3) {
               fprintf(stderr, "%s name size [seals]\n", argv[0]);
               fprintf(stderr, "\t'seals' can contain any of the "
                       "following characters:\n");
               fprintf(stderr, "\t\tg - F_SEAL_GROW\n");
               fprintf(stderr, "\t\ts - F_SEAL_SHRINK\n");
               fprintf(stderr, "\t\tw - F_SEAL_WRITE\n");
               fprintf(stderr, "\t\tS - F_SEAL_SEAL\n");

           name = argv[1];
           len = atoi(argv[2]);
           seals_arg = argv[3];

           /* Create an anonymous file in tmpfs; allow seals to be
              placed on the file */

           fd = memfd_create(name, MFD_ALLOW_SEALING);
           if (fd == -1)

           /* Size the file as specified on the command line */

           if (ftruncate(fd, len) == -1)

           printf("PID: %ld; fd: %d; /proc/%ld/fd/%d\n",
                   (long) getpid(), fd, (long) getpid(), fd);

           /* Code to map the file and populate the mapping with data
              omitted */

           /* If a 'seals' command-line argument was supplied, set some
              seals on the file */

           if (seals_arg != NULL) {
               seals = 0;

               if (strchr(seals_arg, 'g') != NULL)
                   seals |= F_SEAL_GROW;
               if (strchr(seals_arg, 's') != NULL)
                   seals |= F_SEAL_SHRINK;
               if (strchr(seals_arg, 'w') != NULL)
                   seals |= F_SEAL_WRITE;
               if (strchr(seals_arg, 'S') != NULL)
                   seals |= F_SEAL_SEAL;

               if (fcntl(fd, F_ADD_SEALS, seals) == -1)

           /* Keep running, so that the file created by memfd_create()
              continues to exist */



   Program source: t_get_seals.c

       #include <sys/memfd.h>
       #include <fcntl.h>
       #include <unistd.h>
       #include <stdlib.h>
       #include <string.h>
       #include <stdio.h>

       #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                               } while (0)

       main(int argc, char *argv[])
           int fd;
           unsigned int seals;

           if (argc != 2) {
               fprintf(stderr, "%s /proc/PID/fd/FD\n", argv[0]);

           fd = open(argv[1], O_RDWR);
           if (fd == -1)

           seals = fcntl(fd, F_GET_SEALS);
           if (seals == -1)

           printf("Existing seals:");
           if (seals & F_SEAL_SEAL)
               printf(" SEAL");
           if (seals & F_SEAL_GROW)
               printf(" GROW");
           if (seals & F_SEAL_WRITE)
               printf(" WRITE");
           if (seals & F_SEAL_SHRINK)
               printf(" SHRINK");

           /* Code to map the file and access the contents of the
              resulting mapping omitted */



       fcntl(2), ftruncate(2), mmap(2), shmget(2), shm_open(3)


       This  page  is  part of release 4.04 of the Linux man-pages project.  A
       description of the project, information about reporting bugs,  and  the
       latest     version     of     this    page,    can    be    found    at