Provided by: manpages-dev_5.05-1_all bug

NAME

       memfd_create - create an anonymous file

SYNOPSIS

       #define _GNU_SOURCE         /* See feature_test_macros(7) */
       #include <sys/mman.h>

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

DESCRIPTION

       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():

       MFD_CLOEXEC
              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.

       MFD_ALLOW_SEALING
              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.

       MFD_HUGETLB (since Linux 4.14)
              The anonymous file will be created in the hugetlbfs filesystem  using  huge  pages.
              See  the  Linux kernel source file Documentation/admin-guide/mm/hugetlbpage.rst for
              more   information   about   hugetlbfs.    Specifying    both    MFD_HUGETLB    and
              MFD_ALLOW_SEALING in flags is supported since Linux 4.16.

       MFD_HUGE_2MB, MFD_HUGE_1GB, ...
              Used  in  conjunction  with  MFD_HUGETLB  to  select alternative hugetlb page sizes
              (respectively, 2 MB, 1 GB, ...)  on systems  that  support  multiple  hugetlb  page
              sizes.   Definitions  for  known  huge  page  sizes are included in the header file
              <linux/memfd.h>.

              For details on encoding huge page sizes not included in the header  file,  see  the
              discussion of the similarly named constants in mmap(2).

       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 file descriptor.

       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.

RETURN VALUE

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

ERRORS

       EFAULT The address in name points to invalid memory.

       EINVAL flags included unknown bits.

       EINVAL name was too long.  (The limit is 249 bytes, excluding the terminating null byte.)

       EINVAL Both MFD_HUGETLB and MFD_ALLOW_SEALING were specified in flags.

       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 reached.

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

VERSIONS

       The  memfd_create()  system  call first appeared in Linux 3.17; glibc support was added in
       version 2.27.

CONFORMING TO

       The memfd_create() system call is Linux-specific.

NOTES

       The memfd_create() system call provides  a  simple  alternative  to  manually  mounting  a
       tmpfs(5)  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 signal.)

       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(5) 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.  Otherwise,  behavior  similar  to  F_SEAL_WRITE  can  be
          achieved by using F_SEAL_FUTURE_WRITE, which will prevent future writes via mmap(2) and
          write(2) from succeeding while keeping existing shared writable mappings).

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

          *  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/<pid>/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 applied).

EXAMPLE

       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(5) 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 argument 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(5) 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  file  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

       #define _GNU_SOURCE
       #include <sys/mman.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)

       int
       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\tW - F_SEAL_FUTURE_WRITE\n");
               fprintf(stderr, "\t\tS - F_SEAL_SEAL\n");
               exit(EXIT_FAILURE);
           }

           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)
               errExit("memfd_create");

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

           if (ftruncate(fd, len) == -1)
               errExit("truncate");

           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, 'W') != NULL)
                   seals |= F_SEAL_FUTURE_WRITE;
               if (strchr(seals_arg, 'S') != NULL)
                   seals |= F_SEAL_SEAL;

               if (fcntl(fd, F_ADD_SEALS, seals) == -1)
                   errExit("fcntl");
           }

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

           pause();

           exit(EXIT_SUCCESS);
       }

   Program source: t_get_seals.c

       #define _GNU_SOURCE
       #include <sys/mman.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)

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

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

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

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

           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_FUTURE_WRITE)
               printf(" FUTURE_WRITE");
           if (seals & F_SEAL_SHRINK)
               printf(" SHRINK");
           printf("\n");

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

           exit(EXIT_SUCCESS);
       }

SEE ALSO

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

COLOPHON

       This page is part of release 5.05 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 https://www.kernel.org/doc/man-pages/.