src/libpakfire/mount.c

   1 /*#############################################################################
   2 #                                                                             #
   3 # Pakfire - The IPFire package management system                              #
   4 # Copyright (C) 2022 Pakfire development team                                 #
   5 #                                                                             #
   6 # This program is free software: you can redistribute it and/or modify        #
   7 # it under the terms of the GNU General Public License as published by        #
   8 # the Free Software Foundation, either version 3 of the License, or           #
   9 # (at your option) any later version.                                         #
  10 #                                                                             #
  11 # This program is distributed in the hope that it will be useful,             #
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  14 # GNU General Public License for more details.                                #
  15 #                                                                             #
  16 # You should have received a copy of the GNU General Public License           #
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  18 #                                                                             #
  19 #############################################################################*/
  20
  21 #include <errno.h>
  22 #include <linux/limits.h>
  23 #include <stddef.h>
  24 #include <sys/mount.h>
  25 #include <sys/stat.h>
  26 #include <sys/sysmacros.h>
  27 #include <sys/types.h>
  28
  29 // libmount
  30 #include <libmount/libmount.h>
  31
  32 #include <pakfire/arch.h>
  33 #include <pakfire/logging.h>
  34 #include <pakfire/pakfire.h>
  35 #include <pakfire/mount.h>
  36 #include <pakfire/string.h>
  37 #include <pakfire/util.h>
  38
  39 static const struct pakfire_mountpoint {
  40         const char* source;
  41         const char* target;
  42         const char* fstype;
  43         int flags;
  44         const char* options;
  45 } mountpoints[] = {
  46         // Mount a new instance of /proc
  47         { "pakfire_proc",        "proc",               "proc",
  48                 MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL, },
  49
  50         // Make /proc/sys read-only (except /proc/sys/net)
  51         { "/proc/sys",           "proc/sys",           "bind",   MS_BIND|MS_REC, NULL, },
  52         { "/proc/sys/net",       "proc/sys/net",       "bind",   MS_BIND|MS_REC, NULL, },
  53         { "/proc/sys",           "proc/sys",           "bind",
  54                 MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, NULL, },
  55
  56         // Deny write access to /proc/sysrq-trigger (can be used to restart the host)
  57         { "/proc/sysrq-trigger", "proc/sysrq-trigger", "bind",   MS_BIND|MS_REC, NULL, },
  58         { "/proc/sysrq-trigger", "proc/sysrq-trigger", "bind",
  59                 MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, NULL, },
  60
  61         // Make /proc/irq read-only
  62         { "/proc/irq",           "proc/irq",           "bind",   MS_BIND|MS_REC, NULL, },
  63         { "/proc/irq",           "proc/irq",           "bind",
  64                 MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, NULL, },
  65
  66         // Make /proc/bus read-only
  67         { "/proc/bus",           "proc/bus",           "bind",   MS_BIND|MS_REC, NULL, },
  68         { "/proc/bus",           "proc/bus",           "bind",
  69                 MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, NULL, },
  70
  71         // Bind-Mount /sys ready-only
  72         { "/sys",                "sys",                "bind",   MS_BIND|MS_REC, NULL, },
  73         { "/sys",                "sys",                "bind",
  74                 MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, NULL, },
  75
  76         // Create a new /dev
  77         { "pakfire_dev",         "dev",                "tmpfs",  MS_NOSUID|MS_NOEXEC,
  78                 "mode=0755,size=4m,nr_inodes=64k", },
  79         { "pakfire_dev_pts",     "dev/pts",            "devpts", MS_NOSUID|MS_NOEXEC,
  80                 "newinstance,ptmxmode=0666,mode=620", },
  81
  82         // Create a new /dev/shm
  83         { "pakfire_dev_shm",     "dev/shm",            "tmpfs",
  84                 MS_NOSUID|MS_NODEV|MS_STRICTATIME, "mode=1777,size=1024m", },
  85
  86         // Mount /dev/mqueue
  87         { "mqueue",               "dev/mqueue",        "mqueue",
  88                 MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL },
  89
  90         // Create a new /run
  91         { "pakfire_run",          "run",               "tmpfs",  MS_NOSUID|MS_NOEXEC|MS_NODEV,
  92                 "mode=755,size=256m,nr_inodes=1k", },
  93
  94         // Create a new /tmp
  95         { "pakfire_tmp",          "tmp",               "tmpfs",
  96                 MS_NOSUID|MS_NODEV|MS_STRICTATIME, "mode=1777,size=1024m", },
  97
  98         // The end
  99         { NULL },
 100 };
 101
 102 static const struct pakfire_devnode {
 103         const char* path;
 104         int major;
 105         int minor;
 106         mode_t mode;
 107 } devnodes[] = {
 108         { "/dev/null",      1,  3, S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH, },
 109         { "/dev/zero",      1,  5, S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH, },
 110         { "/dev/full",      1,  7, S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH, },
 111         { "/dev/random",    1,  8, S_IFCHR|S_IRUSR|S_IRGRP|S_IROTH, },
 112         { "/dev/urandom",   1,  9, S_IFCHR|S_IRUSR|S_IRGRP|S_IROTH, },
 113         { "/dev/kmsg",      1, 11, S_IFCHR|S_IRUSR|S_IRGRP|S_IROTH, },
 114         { "/dev/tty",       5,  0, S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH, },
 115         { "/dev/console",   5,  1, S_IFCHR|S_IRUSR|S_IWUSR, },
 116         { "/dev/rtc0",    252,  0, S_IFCHR|S_IRUSR|S_IWUSR, },
 117         { NULL },
 118 };
 119
 120 static const struct pakfire_symlink {
 121         const char* target;
 122         const char* path;
 123 } symlinks[] = {
 124         { "/dev/pts/ptmx",   "/dev/ptmx", },
 125         { "/proc/self/fd",   "/dev/fd", },
 126         { "/proc/self/fd/0", "/dev/stdin" },
 127         { "/proc/self/fd/1", "/dev/stdout" },
 128         { "/proc/self/fd/2", "/dev/stderr" },
 129         { "/proc/kcore",     "/dev/core" },
 130         { NULL },
 131 };
 132
 133 /*
 134         Easy way to iterate through all mountpoints
 135 */
 136 static int pakfire_mount_foreach(struct pakfire* pakfire, int direction,
 137                 int (*callback)(struct pakfire* pakfire, struct libmnt_fs* fs, const void* data),
 138                 const void* data) {
 139         const char* root = pakfire_get_path(pakfire);
 140         int r = 0;
 141
 142         struct libmnt_iter* iterator = NULL;
 143         struct libmnt_table* tab = NULL;
 144         struct libmnt_fs* fs = NULL;
 145
 146         // Create an iterator
 147         iterator = mnt_new_iter(direction);
 148         if (!iterator) {
 149                 ERROR(pakfire, "Could not setup iterator: %m\n");
 150                 goto ERROR;
 151         }
 152
 153         // Read /proc/mounts
 154         tab = mnt_new_table_from_file("/proc/mounts");
 155         if (!tab) {
 156                 ERROR(pakfire, "Could not open /proc/mounts: %m\n");
 157                 goto ERROR;
 158         }
 159
 160         while (mnt_table_next_fs(tab, iterator, &fs) == 0) {
 161                 const char* target = mnt_fs_get_target(fs);
 162
 163                 // Ignore any mointpoints that don't belong to us
 164                 if (!pakfire_string_startswith(target, root))
 165                         continue;
 166
 167                 // Call the callback for each relevant mountpoint
 168                 r = callback(pakfire, fs, data);
 169                 if (r)
 170                         break;
 171         }
 172
 173 ERROR:
 174         // Tidy up
 175         if (fs)
 176                 mnt_unref_fs(fs);
 177         if (tab)
 178                 mnt_unref_table(tab);
 179         if (iterator)
 180                 mnt_free_iter(iterator);
 181
 182         return r;
 183 }
 184
 185 static int __pakfire_is_mountpoint(struct pakfire* pakfire,
 186                 struct libmnt_fs* fs, const void* data) {
 187         const char* path = (const char*)data;
 188
 189         return mnt_fs_streq_target(fs, path);
 190 }
 191
 192 int pakfire_is_mountpoint(struct pakfire* pakfire, const char* path) {
 193         return pakfire_mount_foreach(pakfire, MNT_ITER_FORWARD,
 194                 __pakfire_is_mountpoint, path);
 195 }
 196
 197 static int pakfire_mount(struct pakfire* pakfire, const char* source, const char* target,
 198                 const char* fstype, unsigned long mflags, const void* data) {
 199         const char* options = (const char*)data;
 200
 201         // Check for some basic inputs
 202         if (!source || !target) {
 203                 errno = EINVAL;
 204                 return 1;
 205         }
 206
 207         DEBUG(pakfire, "Mounting %s from %s (%s - %s)\n", target, source, fstype, options);
 208
 209         // Perform mount()
 210         int r = mount(source, target, fstype, mflags, data);
 211         if (r) {
 212                 ERROR(pakfire, "Could not mount %s: %m\n", target);
 213         }
 214
 215         return r;
 216 }
 217
 218 static int __pakfire_mount_print(struct pakfire* pakfire,
 219                 struct libmnt_fs* fs, const void* data) {
 220         DEBUG(pakfire,
 221                 "  %s %s %s %s\n",
 222                 mnt_fs_get_source(fs),
 223                 mnt_fs_get_target(fs),
 224                 mnt_fs_get_fstype(fs),
 225                 mnt_fs_get_fs_options(fs)
 226         );
 227
 228         return 0;
 229 }
 230
 231 int pakfire_mount_list(struct pakfire* pakfire) {
 232         DEBUG(pakfire, "Mountpoints:\n");
 233
 234         return pakfire_mount_foreach(pakfire, MNT_ITER_FORWARD,
 235                 __pakfire_mount_print, NULL);
 236 }
 237
 238 static int pakfire_populate_dev(struct pakfire* pakfire) {
 239         char path[PATH_MAX];
 240
 241         // Create device nodes
 242         for (const struct pakfire_devnode* devnode = devnodes; devnode->path; devnode++) {
 243                 DEBUG(pakfire, "Creating device node %s\n", devnode->path);
 244
 245                 int r = pakfire_make_path(pakfire, path, devnode->path);
 246                 if (r < 0)
 247                         return 1;
 248
 249                 dev_t dev = makedev(devnode->major, devnode->minor);
 250
 251                 r = mknod(path, devnode->mode, dev);
 252
 253                 // Continue if mknod was successful
 254                 if (r == 0)
 255                         continue;
 256
 257                 // If we could not create the device node because of permission issues,
 258                 // it might be likely that we are running in a user namespace where creating
 259                 // device nodes is not permitted. Try bind-mounting them.
 260                 if (errno == EPERM)
 261                         goto MOUNT;
 262
 263                 // Otherwise log an error and end
 264                 ERROR(pakfire, "Could not create %s: %m\n", devnode->path);
 265                 return r;
 266
 267 MOUNT:
 268                 // Create an empty file
 269                 r = pakfire_touch(path, 0444);
 270                 if (r) {
 271                         ERROR(pakfire, "Could not create %s: %m\n", path);
 272                         return r;
 273                 }
 274
 275                 // Create a bind-mount over the file
 276                 r = pakfire_mount(pakfire, path, devnode->path, "bind", MS_BIND, NULL);
 277                 if (r)
 278                         return r;
 279         }
 280
 281         // Create symlinks
 282         for (const struct pakfire_symlink* s = symlinks; s->target; s++) {
 283                 DEBUG(pakfire, "Creating symlink %s -> %s\n", s->path, s->target);
 284
 285                 int r = pakfire_make_path(pakfire, path, s->path);
 286                 if (r < 0)
 287                         return 1;
 288
 289                 r = symlink(s->target, path);
 290                 if (r) {
 291                         ERROR(pakfire, "Could not create symlink %s: %m\n", s->path);
 292                         return r;
 293                 }
 294         }
 295
 296         return 0;
 297 }
 298
 299 static int pakfire_mount_interpreter(struct pakfire* pakfire) {
 300         char target[PATH_MAX];
 301
 302         // Fetch the target architecture
 303         const char* arch = pakfire_get_arch(pakfire);
 304
 305         // Can we emulate this architecture?
 306         char* interpreter = pakfire_arch_find_interpreter(arch);
 307
 308         // No interpreter required
 309         if (!interpreter)
 310                 return 0;
 311
 312         DEBUG(pakfire, "Mounting interpreter %s for %s\n", interpreter, arch);
 313
 314         // Where to mount this?
 315         int r = pakfire_make_path(pakfire, target, interpreter);
 316         if (r < 0)
 317                 return r;
 318
 319         // Create directory
 320         r = pakfire_mkparentdir(target, 0755);
 321         if (r)
 322                 return r;
 323
 324         // Create an empty file
 325         FILE* f = fopen(target, "w");
 326         if (!f)
 327                 return 1;
 328         fclose(f);
 329
 330         r = pakfire_mount(pakfire, interpreter, target, NULL, MS_BIND|MS_RDONLY, NULL);
 331         if (r)
 332                 ERROR(pakfire, "Could not mount interpreter %s to %s: %m\n", interpreter, target);
 333
 334         return r;
 335 }
 336
 337 int pakfire_mount_all(struct pakfire* pakfire) {
 338         char target[PATH_MAX];
 339         int r;
 340
 341         // Fetch Pakfire's root directory
 342         const char* root = pakfire_get_path(pakfire);
 343
 344         for (const struct pakfire_mountpoint* mp = mountpoints; mp->source; mp++) {
 345                 // Figure out where to mount
 346                 r = pakfire_path_join(target, root, mp->target);
 347                 if (r < 0)
 348                         return r;
 349
 350                 // Create target
 351                 pakfire_mkdir(target, 0755);
 352
 353 RETRY:
 354                 // Perform mount()
 355                 r = pakfire_mount(pakfire, mp->source, target, mp->fstype, mp->flags, mp->options);
 356                 if (r) {
 357                         // If the target directory does not exist, we will create it
 358                         if (errno == ENOENT) {
 359                                 r = pakfire_mkdir(target, 0755);
 360                                 if (r) {
 361                                         ERROR(pakfire, "Could not create %s\n", target);
 362                                         return r;
 363                                 }
 364
 365                                 goto RETRY;
 366                         }
 367
 368                         return r;
 369                 }
 370         }
 371
 372         // Populate /dev
 373         r = pakfire_populate_dev(pakfire);
 374         if (r)
 375                 return r;
 376
 377         // Mount the interpreter (if needed)
 378         r = pakfire_mount_interpreter(pakfire);
 379         if (r)
 380                 return r;
 381
 382         return 0;
 383 }
 384
 385 int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags) {
 386         struct stat st;
 387         char mountpoint[PATH_MAX];
 388
 389         if (!dst)
 390                 dst = src;
 391
 392         int r = pakfire_make_path(pakfire, mountpoint, dst);
 393         if (r < 0)
 394                 return 1;
 395
 396         DEBUG(pakfire, "Bind-mounting %s to %s\n", src, mountpoint);
 397
 398         r = stat(src, &st);
 399         if (r < 0) {
 400                 ERROR(pakfire, "Could not stat %s: %m\n", src);
 401                 return 1;
 402         }
 403
 404         // Make sure the mountpoint exists
 405         switch (st.st_mode & S_IFMT) {
 406                 case S_IFDIR:
 407                         r = pakfire_mkdir(mountpoint, st.st_mode);
 408                         if (r && errno != EEXIST)
 409                                 return r;
 410                         break;
 411
 412                 case S_IFREG:
 413                 case S_IFLNK:
 414                         // Make parent directory
 415                         r = pakfire_mkparentdir(mountpoint, 0755);
 416                         if (r)
 417                                 return r;
 418
 419                         // Create a file
 420                         FILE* f = fopen(mountpoint, "w");
 421                         if (!f)
 422                                 return 1;
 423                         fclose(f);
 424                         break;
 425
 426                 default:
 427                         errno = ENOTSUP;
 428                         return 1;
 429         }
 430
 431         // Perform mount
 432         return pakfire_mount(pakfire, src, mountpoint, NULL, flags|MS_REC|MS_BIND, NULL);
 433 }