lib/libc/sys/shm_open.c

   1 /*
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 Kyle Evans <kevans@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice(s), this list of conditions and the following disclaimer as
  11  *    the first lines of this file unmodified other than the possible
  12  *    addition of one or more copyright notices.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice(s), this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  25  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  26  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  27  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  28  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/filio.h>
  36 #include <sys/mman.h>
  37
  38 #include <errno.h>
  39 #include <fcntl.h>
  40 #include <limits.h>
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45
  46 #include "libc_private.h"
  47
  48 __weak_reference(shm_open, _shm_open);
  49 __weak_reference(shm_open, __sys_shm_open);
  50
  51 #define MEMFD_NAME_PREFIX       "memfd:"
  52
  53 int
  54 shm_open(const char *path, int flags, mode_t mode)
  55 {
  56
  57         return (__sys_shm_open2(path, flags | O_CLOEXEC, mode, 0, NULL));
  58 }
  59
  60 int
  61 shm_create_largepage(const char *path, int flags, int psind, int alloc_policy,
  62     mode_t mode)
  63 {
  64         struct shm_largepage_conf slc;
  65         int error, fd, saved_errno;
  66
  67         fd = __sys_shm_open2(path, flags | O_CREAT, mode, SHM_LARGEPAGE, NULL);
  68         if (error == -1)
  69                 return (-1);
  70
  71         memset(&slc, 0, sizeof(slc));
  72         slc.psind = psind;
  73         slc.alloc_policy = alloc_policy;
  74         error = ioctl(fd, FIOSSHMLPGCNF, &slc);
  75         if (error == -1) {
  76                 saved_errno = errno;
  77                 close(fd);
  78                 errno = saved_errno;
  79                 return (-1);
  80         }
  81         return (fd);
  82 }
  83
  84 /*
  85  * The path argument is passed to the kernel, but the kernel doesn't currently
  86  * do anything with it.  Linux exposes it in linprocfs for debugging purposes
  87  * only, but our kernel currently will not do the same.
  88  */
  89 int
  90 memfd_create(const char *name, unsigned int flags)
  91 {
  92         char memfd_name[NAME_MAX + 1];
  93         size_t namelen, *pgs, pgsize;
  94         struct shm_largepage_conf slc;
  95         int error, fd, npgs, oflags, pgidx, saved_errno, shmflags;
  96
  97         if (name == NULL) {
  98                 errno = EBADF;
  99                 return (-1);
 100         }
 101         namelen = strlen(name);
 102         if (namelen + sizeof(MEMFD_NAME_PREFIX) - 1 > NAME_MAX) {
 103                 errno = EINVAL;
 104                 return (-1);
 105         }
 106         if ((flags & ~(MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_HUGETLB |
 107             MFD_HUGE_MASK)) != 0) {
 108                 errno = EINVAL;
 109                 return (-1);
 110         }
 111         /* Size specified but no HUGETLB. */
 112         if ((flags & MFD_HUGE_MASK) != 0 && (flags & MFD_HUGETLB) == 0) {
 113                 errno = EINVAL;
 114                 return (-1);
 115         }
 116
 117         /* We've already validated that we're sufficiently sized. */
 118         snprintf(memfd_name, NAME_MAX + 1, "%s%s", MEMFD_NAME_PREFIX, name);
 119         oflags = O_RDWR;
 120         shmflags = 0;
 121         if ((flags & MFD_CLOEXEC) != 0)
 122                 oflags |= O_CLOEXEC;
 123         if ((flags & MFD_ALLOW_SEALING) != 0)
 124                 shmflags |= SHM_ALLOW_SEALING;
 125         if ((flags & MFD_HUGETLB) != 0)
 126                 shmflags |= SHM_LARGEPAGE;
 127         else
 128                 shmflags |= SHM_GROW_ON_WRITE;
 129         fd = __sys_shm_open2(SHM_ANON, oflags, 0, shmflags, memfd_name);
 130         if (fd == -1 || (flags & MFD_HUGETLB) == 0)
 131                 return (fd);
 132
 133         pgs = NULL;
 134         npgs = getpagesizes(NULL, 0);
 135         if (npgs == -1)
 136                 goto clean;
 137         pgs = calloc(npgs, sizeof(size_t));
 138         if (pgs == NULL)
 139                 goto clean;
 140         error = getpagesizes(pgs, npgs);
 141         if (error == -1)
 142                 goto clean;
 143         pgsize = (size_t)1 << ((flags & MFD_HUGE_MASK) >> MFD_HUGE_SHIFT);
 144         for (pgidx = 0; pgidx < npgs; pgidx++) {
 145                 if (pgsize == pgs[pgidx])
 146                         break;
 147         }
 148         if (pgidx == npgs) {
 149                 errno = EOPNOTSUPP;
 150                 goto clean;
 151         }
 152         free(pgs);
 153         pgs = NULL;
 154
 155         memset(&slc, 0, sizeof(slc));
 156         slc.psind = pgidx;
 157         slc.alloc_policy = SHM_LARGEPAGE_ALLOC_DEFAULT;
 158         error = ioctl(fd, FIOSSHMLPGCNF, &slc);
 159         if (error == -1)
 160                 goto clean;
 161         return (fd);
 162
 163 clean:
 164         saved_errno = errno;
 165         close(fd);
 166         free(pgs);
 167         errno = saved_errno;
 168         return (-1);
 169 }