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