src/remount-fs/remount-fs.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <mntent.h>
   5 #include <sys/prctl.h>
   6 #include <sys/stat.h>
   7 #include <sys/wait.h>
   8 #include <unistd.h>
   9
  10 #include "env-util.h"
  11 #include "exit-status.h"
  12 #include "fstab-util.h"
  13 #include "log.h"
  14 #include "main-func.h"
  15 #include "mount-setup.h"
  16 #include "mount-util.h"
  17 #include "path-util.h"
  18 #include "process-util.h"
  19 #include "signal-util.h"
  20 #include "strv.h"
  21
  22 /* Goes through /etc/fstab and remounts all API file systems, applying options that are in /etc/fstab that systemd
  23  * might not have respected */
  24
  25 static int track_pid(Hashmap **h, const char *path, pid_t pid) {
  26         _cleanup_free_ char *c = NULL;
  27         int r;
  28
  29         assert(h);
  30         assert(path);
  31         assert(pid_is_valid(pid));
  32
  33         c = strdup(path);
  34         if (!c)
  35                 return log_oom();
  36
  37         r = hashmap_ensure_put(h, NULL, PID_TO_PTR(pid), c);
  38         if (r == -ENOMEM)
  39                 return log_oom();
  40         if (r < 0)
  41                 return log_error_errno(r, "Failed to store pid " PID_FMT, pid);
  42
  43         TAKE_PTR(c);
  44         return 0;
  45 }
  46
  47 static int do_remount(const char *path, bool force_rw, Hashmap **pids) {
  48         pid_t pid;
  49         int r;
  50
  51         log_debug("Remounting %s...", path);
  52
  53         r = safe_fork(force_rw ? "(remount-rw)" : "(remount)",
  54                       FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGTERM|FORK_RLIMIT_NOFILE_SAFE|FORK_LOG, &pid);
  55         if (r < 0)
  56                 return r;
  57         if (r == 0) {
  58                 /* Child */
  59                 execv(MOUNT_PATH,
  60                       STRV_MAKE(MOUNT_PATH,
  61                                 path,
  62                                 "-o",
  63                                 force_rw ? "remount,rw" : "remount"));
  64                 log_error_errno(errno, "Failed to execute " MOUNT_PATH ": %m");
  65                 _exit(EXIT_FAILURE);
  66         }
  67
  68         /* Parent */
  69         return track_pid(pids, path, pid);
  70 }
  71
  72 static int remount_by_fstab(Hashmap **ret_pids) {
  73         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
  74         _cleanup_endmntent_ FILE *f = NULL;
  75         bool has_root = false;
  76         struct mntent* me;
  77         int r;
  78
  79         assert(ret_pids);
  80
  81         if (!fstab_enabled())
  82                 return 0;
  83
  84         f = setmntent(fstab_path(), "re");
  85         if (!f) {
  86                 if (errno != ENOENT)
  87                         return log_error_errno(errno, "Failed to open %s: %m", fstab_path());
  88
  89                 return 0;
  90         }
  91
  92         while ((me = getmntent(f))) {
  93                 /* Remount the root fs, /usr, and all API VFSs */
  94                 if (!mount_point_is_api(me->mnt_dir) &&
  95                     !PATH_IN_SET(me->mnt_dir, "/", "/usr"))
  96                         continue;
  97
  98                 if (path_equal(me->mnt_dir, "/"))
  99                         has_root = true;
 100
 101                 r = do_remount(me->mnt_dir, false, &pids);
 102                 if (r < 0)
 103                         return r;
 104         }
 105
 106         *ret_pids = TAKE_PTR(pids);
 107         return has_root;
 108 }
 109
 110 static int run(int argc, char *argv[]) {
 111         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
 112         int r;
 113
 114         log_setup();
 115
 116         if (argc > 1)
 117                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 118                                        "This program takes no arguments.");
 119
 120         umask(0022);
 121
 122         r = remount_by_fstab(&pids);
 123         if (r < 0)
 124                 return r;
 125         if (r == 0) {
 126                 /* The $SYSTEMD_REMOUNT_ROOT_RW environment variable is set by systemd-gpt-auto-generator to tell us
 127                  * whether to remount things. We honour it only if there's no explicit line in /etc/fstab configured
 128                  * which takes precedence. */
 129
 130                 r = getenv_bool("SYSTEMD_REMOUNT_ROOT_RW");
 131                 if (r < 0 && r != -ENXIO)
 132                         log_warning_errno(r, "Failed to parse $SYSTEMD_REMOUNT_ROOT_RW, ignoring: %m");
 133
 134                 if (r > 0) {
 135                         r = do_remount("/", true, &pids);
 136                         if (r < 0)
 137                                 return r;
 138                 }
 139         }
 140
 141         r = 0;
 142         while (!hashmap_isempty(pids)) {
 143                 _cleanup_free_ char *s = NULL;
 144                 siginfo_t si = {};
 145
 146                 if (waitid(P_ALL, 0, &si, WEXITED) < 0) {
 147                         if (errno == EINTR)
 148                                 continue;
 149
 150                         return log_error_errno(errno, "waitid() failed: %m");
 151                 }
 152
 153                 s = hashmap_remove(pids, PID_TO_PTR(si.si_pid));
 154                 if (s &&
 155                     !is_clean_exit(si.si_code, si.si_status, EXIT_CLEAN_COMMAND, NULL)) {
 156                         if (si.si_code == CLD_EXITED)
 157                                 log_error(MOUNT_PATH " for %s exited with exit status %i.", s, si.si_status);
 158                         else
 159                                 log_error(MOUNT_PATH " for %s terminated by signal %s.", s, signal_to_string(si.si_status));
 160
 161                         r = -ENOEXEC;
 162                 }
 163         }
 164
 165         return r;
 166 }
 167
 168 DEFINE_MAIN_FUNCTION(run);