src/basic/memfd-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24 #if HAVE_LINUX_MEMFD_H
  25 #include <linux/memfd.h>
  26 #endif
  27 #include <stdio.h>
  28 #include <sys/mman.h>
  29 #include <sys/prctl.h>
  30
  31 #include "alloc-util.h"
  32 #include "fd-util.h"
  33 #include "macro.h"
  34 #include "memfd-util.h"
  35 #include "missing.h"
  36 #include "string-util.h"
  37 #include "utf8.h"
  38
  39 int memfd_new(const char *name) {
  40         _cleanup_free_ char *g = NULL;
  41         int fd;
  42
  43         if (!name) {
  44                 char pr[17] = {};
  45
  46                 /* If no name is specified we generate one. We include
  47                  * a hint indicating our library implementation, and
  48                  * add the thread name to it */
  49
  50                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
  51
  52                 if (isempty(pr))
  53                         name = "sd";
  54                 else {
  55                         _cleanup_free_ char *e = NULL;
  56
  57                         e = utf8_escape_invalid(pr);
  58                         if (!e)
  59                                 return -ENOMEM;
  60
  61                         g = strappend("sd-", e);
  62                         if (!g)
  63                                 return -ENOMEM;
  64
  65                         name = g;
  66                 }
  67         }
  68
  69         fd = memfd_create(name, MFD_ALLOW_SEALING | MFD_CLOEXEC);
  70         if (fd < 0)
  71                 return -errno;
  72
  73         return fd;
  74 }
  75
  76 int memfd_map(int fd, uint64_t offset, size_t size, void **p) {
  77         void *q;
  78         int sealed;
  79
  80         assert(fd >= 0);
  81         assert(size > 0);
  82         assert(p);
  83
  84         sealed = memfd_get_sealed(fd);
  85         if (sealed < 0)
  86                 return sealed;
  87
  88         if (sealed)
  89                 q = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, offset);
  90         else
  91                 q = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, offset);
  92
  93         if (q == MAP_FAILED)
  94                 return -errno;
  95
  96         *p = q;
  97         return 0;
  98 }
  99
 100 int memfd_set_sealed(int fd) {
 101         int r;
 102
 103         assert(fd >= 0);
 104
 105         r = fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL);
 106         if (r < 0)
 107                 return -errno;
 108
 109         return 0;
 110 }
 111
 112 int memfd_get_sealed(int fd) {
 113         int r;
 114
 115         assert(fd >= 0);
 116
 117         r = fcntl(fd, F_GET_SEALS);
 118         if (r < 0)
 119                 return -errno;
 120
 121         return r == (F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_SEAL);
 122 }
 123
 124 int memfd_get_size(int fd, uint64_t *sz) {
 125         struct stat stat;
 126         int r;
 127
 128         assert(fd >= 0);
 129         assert(sz);
 130
 131         r = fstat(fd, &stat);
 132         if (r < 0)
 133                 return -errno;
 134
 135         *sz = stat.st_size;
 136         return 0;
 137 }
 138
 139 int memfd_set_size(int fd, uint64_t sz) {
 140         int r;
 141
 142         assert(fd >= 0);
 143
 144         r = ftruncate(fd, sz);
 145         if (r < 0)
 146                 return -errno;
 147
 148         return 0;
 149 }
 150
 151 int memfd_new_and_map(const char *name, size_t sz, void **p) {
 152         _cleanup_close_ int fd = -1;
 153         int r;
 154
 155         assert(sz > 0);
 156         assert(p);
 157
 158         fd = memfd_new(name);
 159         if (fd < 0)
 160                 return fd;
 161
 162         r = memfd_set_size(fd, sz);
 163         if (r < 0)
 164                 return r;
 165
 166         r = memfd_map(fd, 0, sz, p);
 167         if (r < 0)
 168                 return r;
 169
 170         r = fd;
 171         fd = -1;
 172
 173         return r;
 174 }