]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/mount.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
core,network: major per-object logging rework
[thirdparty/systemd.git] / src / core / mount.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
5cb5a6ff 2
a7334b09
LP		 3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
5430f7f2
LP		 9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
a7334b09
LP		 11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
5cb5a6ff 22#include <errno.h>
b08d03ff 23#include <stdio.h>
ef734fd6 24#include <sys/epoll.h>
e537352b 25#include <signal.h>
8d3ae2bd 26#include <libmount.h>
befb6d54 27#include <sys/inotify.h>
5cb5a6ff 28
c17ec25e 29#include "manager.h"
87f0e418 30#include "unit.h"
5cb5a6ff 31#include "mount.h"
b08d03ff 32#include "log.h"
20ad4cfd 33#include "sd-messages.h"
e537352b 34#include "strv.h"
49e942b2 35#include "mkdir.h"
9eb977db 36#include "path-util.h"
e537352b 37#include "mount-setup.h"
9e2f7c11 38#include "unit-name.h"
4139c1b2 39#include "dbus-mount.h"
514f4ef5 40#include "special.h"
9a57c629 41#include "exit-status.h"
d15d0333 42#include "fstab-util.h"
6482f626 43#include "formats-util.h"
5cb5a6ff 44
7d54a03a
LP		 45#define RETRY_UMOUNT_MAX 32
46
4e920142
ZJS		 47DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
48DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
49
f50e0a01
LP		 50static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
51 [MOUNT_DEAD] = UNIT_INACTIVE,
52 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
e537352b 53 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
f50e0a01 54 [MOUNT_MOUNTED] = UNIT_ACTIVE,
032ff4af 55 [MOUNT_REMOUNTING] = UNIT_RELOADING,
f50e0a01 56 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
e537352b
LP		 57 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
58 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
032ff4af
LP		 59 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
60 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
e537352b
LP		 61 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
62 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
fdf20a31 63 [MOUNT_FAILED] = UNIT_FAILED
f50e0a01 64};
5cb5a6ff 65
718db961
LP		 66static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
67static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
68
affc3d83 69static bool mount_needs_network(const char *options, const char *fstype) {
d15d0333 70 if (fstab_test_option(options, "_netdev\0"))
fc676b00
ZJS		 71 return true;
72
affc3d83 73 if (fstype && fstype_is_network(fstype))
fc676b00
ZJS		 74 return true;
75
76 return false;
77}
78
e6a7b9f4 79static bool mount_is_network(const MountParameters *p) {
affc3d83
CL		 80 assert(p);
81
82 return mount_needs_network(p->options, p->fstype);
83}
84
e6a7b9f4 85static bool mount_is_bind(const MountParameters *p) {
fc676b00
ZJS		 86 assert(p);
87
d15d0333 88 if (fstab_test_option(p->options, "bind\0" "rbind\0"))
fc676b00
ZJS		 89 return true;
90
d15d0333 91 if (p->fstype && STR_IN_SET(p->fstype, "bind", "rbind"))
fc676b00
ZJS		 92 return true;
93
94 return false;
95}
96
e6a7b9f4 97static bool mount_is_auto(const MountParameters *p) {
fc676b00
ZJS		 98 assert(p);
99
d15d0333 100 return !fstab_test_option(p->options, "noauto\0");
fc676b00
ZJS		 101}
102
e6a7b9f4 103static bool needs_quota(const MountParameters *p) {
fc676b00
ZJS		 104 assert(p);
105
11041c84 106 /* Quotas are not enabled on network filesystems,
340a1d23 107 * but we want them, for example, on storage connected via iscsi */
11041c84 108 if (p->fstype && fstype_is_network(p->fstype))
fc676b00
ZJS		 109 return false;
110
111 if (mount_is_bind(p))
112 return false;
113
d15d0333
ZJS		 114 return fstab_test_option(p->options,
115 "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
fc676b00
ZJS		 116}
117
a16e1123
LP		 118static void mount_init(Unit *u) {
119 Mount *m = MOUNT(u);
5cb5a6ff 120
a16e1123 121 assert(u);
ac155bb8 122 assert(u->load_state == UNIT_STUB);
a16e1123 123
1f19a534 124 m->timeout_usec = u->manager->default_timeout_start_usec;
3e5235b0
LP		 125 m->directory_mode = 0755;
126
6b1dc2bd
LP		 127 if (unit_has_name(u, "-.mount")) {
128 /* Don't allow start/stop for root directory */
5bcb0f2b
LP		 129 u->refuse_manual_start = true;
130 u->refuse_manual_stop = true;
6b1dc2bd
LP		 131 } else {
132 /* The stdio/kmsg bridge socket is on /, in order to avoid a
133 * dep loop, don't use kmsg logging for -.mount */
ac155bb8
MS		 134 m->exec_context.std_output = u->manager->default_std_output;
135 m->exec_context.std_error = u->manager->default_std_error;
f6cebb3b 136 }
c3686083 137
a16e1123
LP		 138 /* We need to make sure that /bin/mount is always called in
139 * the same process group as us, so that the autofs kernel
140 * side doesn't send us another mount request while we are
141 * already trying to comply its last one. */
74922904 142 m->exec_context.same_pgrp = true;
8d567588 143
a16e1123 144 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
c8f4d764 145
5bcb0f2b 146 u->ignore_on_isolate = true;
8d567588
LP		 147}
148
718db961
LP		 149static int mount_arm_timer(Mount *m) {
150 int r;
151
152 assert(m);
153
154 if (m->timeout_usec <= 0) {
155 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
156 return 0;
157 }
158
159 if (m->timer_event_source) {
160 r = sd_event_source_set_time(m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec);
161 if (r < 0)
162 return r;
163
164 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
165 }
166
7dfbe2e3 167 r = sd_event_add_time(
6a0f1f6d
LP		 168 UNIT(m)->manager->event,
169 &m->timer_event_source,
170 CLOCK_MONOTONIC,
171 now(CLOCK_MONOTONIC) + m->timeout_usec, 0,
172 mount_dispatch_timer, m);
7dfbe2e3
TG		 173 if (r < 0)
174 return r;
175
176 (void) sd_event_source_set_description(m->timer_event_source, "mount-timer");
177
178 return 0;
718db961
LP		 179}
180
a16e1123 181static void mount_unwatch_control_pid(Mount *m) {
5e94833f
LP		 182 assert(m);
183
184 if (m->control_pid <= 0)
185 return;
186
187 unit_unwatch_pid(UNIT(m), m->control_pid);
188 m->control_pid = 0;
189}
190
e537352b
LP		 191static void mount_parameters_done(MountParameters *p) {
192 assert(p);
193
194 free(p->what);
195 free(p->options);
196 free(p->fstype);
197
198 p->what = p->options = p->fstype = NULL;
199}
200
87f0e418 201static void mount_done(Unit *u) {
ef734fd6 202 Mount *m = MOUNT(u);
034c6ed7 203
ef734fd6 204 assert(m);
034c6ed7 205
e537352b
LP		 206 free(m->where);
207 m->where = NULL;
f50e0a01 208
e537352b
LP		 209 mount_parameters_done(&m->parameters_proc_self_mountinfo);
210 mount_parameters_done(&m->parameters_fragment);
ef734fd6 211
613b411c 212 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
e537352b
LP		 213 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
214 m->control_command = NULL;
f50e0a01 215
a16e1123 216 mount_unwatch_control_pid(m);
f50e0a01 217
718db961 218 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
f50e0a01
LP		 219}
220
44a6b1b6 221_pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
cb39ed3f
LP		 222 assert(m);
223
224 if (m->from_fragment)
225 return &m->parameters_fragment;
cb39ed3f
LP		 226
227 return NULL;
228}
229
44a6b1b6 230_pure_ static MountParameters* get_mount_parameters(Mount *m) {
cb39ed3f
LP		 231 assert(m);
232
233 if (m->from_proc_self_mountinfo)
234 return &m->parameters_proc_self_mountinfo;
235
6b1dc2bd 236 return get_mount_parameters_fragment(m);
cb39ed3f
LP		 237}
238
6e2ef85b 239static int mount_add_mount_links(Mount *m) {
a57f7e2c 240 _cleanup_free_ char *parent = NULL;
5c78d8e2 241 MountParameters *pm;
ac155bb8 242 Unit *other;
a57f7e2c
LP		 243 Iterator i;
244 Set *s;
b08d03ff
LP		 245 int r;
246
6e2ef85b 247 assert(m);
b08d03ff 248
a57f7e2c
LP		 249 if (!path_equal(m->where, "/")) {
250 /* Adds in links to other mount points that might lie further
251 * up in the hierarchy */
252 r = path_get_parent(m->where, &parent);
4f0eedb7 253 if (r < 0)
6e2ef85b 254 return r;
01f78473 255
a57f7e2c 256 r = unit_require_mounts_for(UNIT(m), parent);
4f0eedb7 257 if (r < 0)
01f78473 258 return r;
4f0eedb7 259 }
01f78473 260
a57f7e2c
LP		 261 /* Adds in links to other mount points that might be needed
262 * for the source path (if this is a bind mount) to be
263 * available. */
264 pm = get_mount_parameters_fragment(m);
fc676b00
ZJS		 265 if (pm && pm->what &&
266 path_is_absolute(pm->what) &&
267 !mount_is_network(pm)) {
268
a57f7e2c 269 r = unit_require_mounts_for(UNIT(m), pm->what);
4f0eedb7 270 if (r < 0)
6e2ef85b 271 return r;
4f0eedb7 272 }
b08d03ff 273
a57f7e2c
LP		 274 /* Adds in links to other units that use this path or paths
275 * further down in the hierarchy */
276 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
277 SET_FOREACH(other, s, i) {
b08d03ff 278
a57f7e2c
LP		 279 if (other->load_state != UNIT_LOADED)
280 continue;
b08d03ff 281
a57f7e2c
LP		 282 if (other == UNIT(m))
283 continue;
b08d03ff 284
a57f7e2c 285 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
4f0eedb7 286 if (r < 0)
6e2ef85b 287 return r;
b08d03ff 288
a57f7e2c
LP		 289 if (UNIT(m)->fragment_path) {
290 /* If we have fragment configuration, then make this dependency required */
291 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
292 if (r < 0)
293 return r;
294 }
7c8fa05c
LP		 295 }
296
297 return 0;
298}
299
173a8d04
LP		 300static int mount_add_device_links(Mount *m) {
301 MountParameters *p;
5073f89f 302 bool device_wants_mount = false;
9fff8a1f 303 int r;
173a8d04
LP		 304
305 assert(m);
306
06e97888 307 p = get_mount_parameters(m);
6b1dc2bd 308 if (!p)
173a8d04
LP		 309 return 0;
310
9fff8a1f 311 if (!p->what)
173a8d04 312 return 0;
5c78d8e2 313
dd144c63
LP		 314 if (mount_is_bind(p))
315 return 0;
316
317 if (!is_device_path(p->what))
318 return 0;
319
320 if (path_equal(m->where, "/"))
321 return 0;
322
5073f89f
TG		 323 if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
324 device_wants_mount = true;
325
326 r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
dd144c63
LP		 327 if (r < 0)
328 return r;
9fff8a1f 329
9fff8a1f 330 return 0;
173a8d04
LP		 331}
332
6b1dc2bd
LP		 333static int mount_add_quota_links(Mount *m) {
334 int r;
335 MountParameters *p;
336
337 assert(m);
338
67445f4e 339 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
6b1dc2bd
LP		 340 return 0;
341
342 p = get_mount_parameters_fragment(m);
343 if (!p)
344 return 0;
345
346 if (!needs_quota(p))
347 return 0;
348
349 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
350 if (r < 0)
351 return r;
352
353 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
354 if (r < 0)
355 return r;
356
357 return 0;
358}
359
88ac30a1
TG		 360static bool should_umount(Mount *m) {
361 MountParameters *p;
362
363 if (path_equal(m->where, "/") ||
364 path_equal(m->where, "/usr"))
365 return false;
366
367 p = get_mount_parameters(m);
d15d0333 368 if (p && fstab_test_option(p->options, "x-initrd.mount\0") &&
88ac30a1
TG		 369 !in_initrd())
370 return false;
371
372 return true;
373}
374
2edd4434 375static int mount_add_default_dependencies(Mount *m) {
0c17fbce 376 const char *after, *after2, *online;
9ddc4a26 377 MountParameters *p;
0c17fbce 378 int r;
2edd4434
LP		 379
380 assert(m);
381
67445f4e 382 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
9ddc4a26 383 return 0;
cb39ed3f 384
874d3404
LP		 385 /* We do not add any default dependencies to / and /usr, since
386 * they are guaranteed to stay mounted the whole time, since
387 * our system is on it. Also, don't bother with anything
388 * mounted below virtual file systems, it's also going to be
389 * virtual, and hence not worth the effort. */
390 if (path_equal(m->where, "/") ||
391 path_equal(m->where, "/usr") ||
392 path_startswith(m->where, "/proc") ||
393 path_startswith(m->where, "/sys") ||
394 path_startswith(m->where, "/dev"))
6b1dc2bd 395 return 0;
2edd4434 396
874d3404
LP		 397 p = get_mount_parameters(m);
398 if (!p)
6b1dc2bd
LP		 399 return 0;
400
e8d2f6cd 401 if (mount_is_network(p)) {
6b1dc2bd 402 after = SPECIAL_REMOTE_FS_PRE_TARGET;
a63a5c46 403 after2 = SPECIAL_NETWORK_TARGET;
0c17fbce 404 online = SPECIAL_NETWORK_ONLINE_TARGET;
e8d2f6cd 405 } else {
6b1dc2bd 406 after = SPECIAL_LOCAL_FS_PRE_TARGET;
a63a5c46 407 after2 = NULL;
0c17fbce 408 online = NULL;
e8d2f6cd 409 }
6b1dc2bd 410
e8d2f6cd 411 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
6b1dc2bd
LP		 412 if (r < 0)
413 return r;
414
a63a5c46
LP		 415 if (after2) {
416 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
417 if (r < 0)
418 return r;
419 }
420
0c17fbce
LP		 421 if (online) {
422 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
e8d2f6cd
LP		 423 if (r < 0)
424 return r;
425 }
426
88ac30a1
TG		 427 if (should_umount(m)) {
428 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
429 if (r < 0)
430 return r;
431 }
2edd4434
LP		 432
433 return 0;
434}
435
8d567588 436static int mount_verify(Mount *m) {
a57f7e2c 437 _cleanup_free_ char *e = NULL;
7410616c 438 int r;
a57f7e2c 439
8d567588
LP		 440 assert(m);
441
1124fe6f 442 if (UNIT(m)->load_state != UNIT_LOADED)
8d567588
LP		 443 return 0;
444
6b1dc2bd 445 if (!m->from_fragment && !m->from_proc_self_mountinfo)
8cbef760
LP		 446 return -ENOENT;
447
7410616c
LP		 448 r = unit_name_from_path(m->where, ".mount", &e);
449 if (r < 0)
f2341e0a 450 return log_unit_error_errno(UNIT(m), r, "Failed to generate unit name from mount path: %m");
8d567588 451
7410616c 452 if (!unit_has_name(UNIT(m), e)) {
f2341e0a 453 log_unit_error(UNIT(m), "Where= setting doesn't match unit name. Refusing.");
8d567588
LP		 454 return -EINVAL;
455 }
456
33ff02c9 457 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
f2341e0a 458 log_unit_error(UNIT(m), "Cannot create mount unit for API file system %s. Refusing.", m->where);
33ff02c9
LP		 459 return -EINVAL;
460 }
461
1124fe6f 462 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
f2341e0a 463 log_unit_error(UNIT(m), "What= setting is missing. Refusing.");
4e85aff4
LP		 464 return -EBADMSG;
465 }
466
4819ff03 467 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
f2341e0a 468 log_unit_error(UNIT(m), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
4d0e5dbd
LP		 469 return -EINVAL;
470 }
471
8d567588
LP		 472 return 0;
473}
474
1a4ac875
MS		 475static int mount_add_extras(Mount *m) {
476 Unit *u = UNIT(m);
e537352b
LP		 477 int r;
478
e821075a
LP		 479 assert(m);
480
481 if (u->fragment_path)
1a4ac875 482 m->from_fragment = true;
e537352b 483
1a4ac875 484 if (!m->where) {
7410616c
LP		 485 r = unit_name_to_path(u->id, &m->where);
486 if (r < 0)
487 return r;
1a4ac875 488 }
a16e1123 489
1a4ac875 490 path_kill_slashes(m->where);
e537352b 491
e821075a 492 if (!u->description) {
1a4ac875
MS		 493 r = unit_set_description(u, m->where);
494 if (r < 0)
173a8d04 495 return r;
1a4ac875 496 }
6e2ef85b 497
1a4ac875
MS		 498 r = mount_add_device_links(m);
499 if (r < 0)
500 return r;
6e2ef85b 501
1a4ac875
MS		 502 r = mount_add_mount_links(m);
503 if (r < 0)
504 return r;
6e2ef85b 505
1a4ac875
MS		 506 r = mount_add_quota_links(m);
507 if (r < 0)
508 return r;
e537352b 509
598459ce
LP		 510 r = unit_patch_contexts(u);
511 if (r < 0)
512 return r;
4e67ddd6 513
598459ce 514 r = unit_add_exec_dependencies(u, &m->exec_context);
a016b922
LP		 515 if (r < 0)
516 return r;
517
598459ce 518 r = unit_add_default_slice(u, &m->cgroup_context);
1a4ac875
MS		 519 if (r < 0)
520 return r;
521
598459ce
LP		 522 if (u->default_dependencies) {
523 r = mount_add_default_dependencies(m);
524 if (r < 0)
525 return r;
526 }
527
1a4ac875
MS		 528 return 0;
529}
530
531static int mount_load(Unit *u) {
532 Mount *m = MOUNT(u);
533 int r;
534
535 assert(u);
536 assert(u->load_state == UNIT_STUB);
537
8eba616f
MS		 538 if (m->from_proc_self_mountinfo)
539 r = unit_load_fragment_and_dropin_optional(u);
540 else
541 r = unit_load_fragment_and_dropin(u);
542
1a4ac875
MS		 543 if (r < 0)
544 return r;
155da457 545
1a4ac875
MS		 546 /* This is a new unit? Then let's add in some extras */
547 if (u->load_state == UNIT_LOADED) {
548 r = mount_add_extras(m);
549 if (r < 0)
550 return r;
e537352b
LP		 551 }
552
8d567588 553 return mount_verify(m);
e537352b
LP		 554}
555
deb0a77c 556static int mount_notify_automount(Mount *m, MountState old_state, MountState state) {
a16e1123
LP		 557 Unit *p;
558 int r;
57020a3a 559 Iterator i;
a16e1123
LP		 560
561 assert(m);
562
1124fe6f 563 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
ac155bb8 564 if (p->type == UNIT_AUTOMOUNT) {
deb0a77c 565 r = automount_update_mount(AUTOMOUNT(p), old_state, state);
57020a3a
LP		 566 if (r < 0)
567 return r;
568 }
a16e1123 569
57020a3a 570 return 0;
a16e1123
LP		 571}
572
e537352b
LP		 573static void mount_set_state(Mount *m, MountState state) {
574 MountState old_state;
575 assert(m);
576
577 old_state = m->state;
578 m->state = state;
579
580 if (state != MOUNT_MOUNTING &&
581 state != MOUNT_MOUNTING_DONE &&
582 state != MOUNT_REMOUNTING &&
583 state != MOUNT_UNMOUNTING &&
584 state != MOUNT_MOUNTING_SIGTERM &&
585 state != MOUNT_MOUNTING_SIGKILL &&
586 state != MOUNT_UNMOUNTING_SIGTERM &&
587 state != MOUNT_UNMOUNTING_SIGKILL &&
588 state != MOUNT_REMOUNTING_SIGTERM &&
589 state != MOUNT_REMOUNTING_SIGKILL) {
718db961 590 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
a16e1123 591 mount_unwatch_control_pid(m);
e537352b 592 m->control_command = NULL;
a16e1123 593 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
e537352b
LP		 594 }
595
deb0a77c 596 mount_notify_automount(m, old_state, state);
8d567588 597
e537352b 598 if (state != old_state)
f2341e0a 599 log_unit_debug(UNIT(m), "Changed %s -> %s", mount_state_to_string(old_state), mount_state_to_string(state));
e537352b 600
9d2f5178
LP		 601 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
602 m->reload_result = MOUNT_SUCCESS;
e537352b
LP		 603}
604
be847e82 605static int mount_coldplug(Unit *u) {
e537352b 606 Mount *m = MOUNT(u);
a16e1123
LP		 607 MountState new_state = MOUNT_DEAD;
608 int r;
e537352b
LP		 609
610 assert(m);
611 assert(m->state == MOUNT_DEAD);
612
a16e1123
LP		 613 if (m->deserialized_state != m->state)
614 new_state = m->deserialized_state;
615 else if (m->from_proc_self_mountinfo)
616 new_state = MOUNT_MOUNTED;
e537352b 617
5bcb0f2b
LP		 618 if (new_state == m->state)
619 return 0;
e537352b 620
5bcb0f2b
LP		 621 if (new_state == MOUNT_MOUNTING ||
622 new_state == MOUNT_MOUNTING_DONE ||
623 new_state == MOUNT_REMOUNTING ||
624 new_state == MOUNT_UNMOUNTING ||
625 new_state == MOUNT_MOUNTING_SIGTERM ||
626 new_state == MOUNT_MOUNTING_SIGKILL ||
627 new_state == MOUNT_UNMOUNTING_SIGTERM ||
628 new_state == MOUNT_UNMOUNTING_SIGKILL ||
629 new_state == MOUNT_REMOUNTING_SIGTERM ||
630 new_state == MOUNT_REMOUNTING_SIGKILL) {
631
632 if (m->control_pid <= 0)
633 return -EBADMSG;
634
635 r = unit_watch_pid(UNIT(m), m->control_pid);
636 if (r < 0)
637 return r;
e537352b 638
5bcb0f2b
LP		 639 r = mount_arm_timer(m);
640 if (r < 0)
641 return r;
a16e1123 642 }
e537352b 643
5bcb0f2b 644 mount_set_state(m, new_state);
e537352b 645 return 0;
e537352b
LP		 646}
647
648static void mount_dump(Unit *u, FILE *f, const char *prefix) {
649 Mount *m = MOUNT(u);
650 MountParameters *p;
651
652 assert(m);
653 assert(f);
654
cb39ed3f 655 p = get_mount_parameters(m);
e537352b
LP		 656
657 fprintf(f,
658 "%sMount State: %s\n"
81a5c6d0 659 "%sResult: %s\n"
e537352b
LP		 660 "%sWhere: %s\n"
661 "%sWhat: %s\n"
662 "%sFile System Type: %s\n"
663 "%sOptions: %s\n"
e537352b
LP		 664 "%sFrom /proc/self/mountinfo: %s\n"
665 "%sFrom fragment: %s\n"
3e5235b0 666 "%sDirectoryMode: %04o\n",
a16e1123 667 prefix, mount_state_to_string(m->state),
81a5c6d0 668 prefix, mount_result_to_string(m->result),
e537352b 669 prefix, m->where,
1e4fc9b1
HH		 670 prefix, p ? strna(p->what) : "n/a",
671 prefix, p ? strna(p->fstype) : "n/a",
672 prefix, p ? strna(p->options) : "n/a",
e537352b
LP		 673 prefix, yes_no(m->from_proc_self_mountinfo),
674 prefix, yes_no(m->from_fragment),
3e5235b0 675 prefix, m->directory_mode);
e537352b
LP		 676
677 if (m->control_pid > 0)
678 fprintf(f,
ccd06097
ZJS		 679 "%sControl PID: "PID_FMT"\n",
680 prefix, m->control_pid);
e537352b
LP		 681
682 exec_context_dump(&m->exec_context, f, prefix);
4819ff03 683 kill_context_dump(&m->kill_context, f, prefix);
e537352b
LP		 684}
685
a16e1123
LP		 686static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
687 pid_t pid;
688 int r;
9fa95f85
DM		 689 ExecParameters exec_params = {
690 .apply_permissions = true,
691 .apply_chroot = true,
692 .apply_tty_stdin = true,
6f856a09 693 .bus_endpoint_fd = -1,
9fa95f85 694 };
a16e1123
LP		 695
696 assert(m);
697 assert(c);
698 assert(_pid);
699
5ad096b3
LP		 700 (void) unit_realize_cgroup(UNIT(m));
701 if (m->reset_cpu_usage) {
702 (void) unit_reset_cpu_usage(UNIT(m));
703 m->reset_cpu_usage = false;
704 }
4ad49000 705
613b411c
LP		 706 r = unit_setup_exec_runtime(UNIT(m));
707 if (r < 0)
708 goto fail;
709
718db961 710 r = mount_arm_timer(m);
36697dc0 711 if (r < 0)
a16e1123
LP		 712 goto fail;
713
9fa95f85
DM		 714 exec_params.environment = UNIT(m)->manager->environment;
715 exec_params.confirm_spawn = UNIT(m)->manager->confirm_spawn;
716 exec_params.cgroup_supported = UNIT(m)->manager->cgroup_supported;
717 exec_params.cgroup_path = UNIT(m)->cgroup_path;
a931ad47 718 exec_params.cgroup_delegate = m->cgroup_context.delegate;
9fa95f85 719 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
9fa95f85 720
f2341e0a
LP		 721 r = exec_spawn(UNIT(m),
722 c,
4ad49000 723 &m->exec_context,
9fa95f85 724 &exec_params,
613b411c 725 m->exec_runtime,
4ad49000
LP		 726 &pid);
727 if (r < 0)
a16e1123
LP		 728 goto fail;
729
4ad49000
LP		 730 r = unit_watch_pid(UNIT(m), pid);
731 if (r < 0)
a16e1123
LP		 732 /* FIXME: we need to do something here */
733 goto fail;
734
735 *_pid = pid;
736
737 return 0;
738
739fail:
718db961 740 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
a16e1123
LP		 741
742 return r;
743}
744
9d2f5178 745static void mount_enter_dead(Mount *m, MountResult f) {
e537352b
LP		 746 assert(m);
747
9d2f5178
LP		 748 if (f != MOUNT_SUCCESS)
749 m->result = f;
e537352b 750
613b411c
LP		 751 exec_runtime_destroy(m->exec_runtime);
752 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
753
e66cf1a3
LP		 754 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
755
9d2f5178 756 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
e537352b
LP		 757}
758
9d2f5178 759static void mount_enter_mounted(Mount *m, MountResult f) {
80876c20
LP		 760 assert(m);
761
9d2f5178
LP		 762 if (f != MOUNT_SUCCESS)
763 m->result = f;
80876c20
LP		 764
765 mount_set_state(m, MOUNT_MOUNTED);
766}
767
9d2f5178 768static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
e537352b
LP		 769 int r;
770
771 assert(m);
772
9d2f5178
LP		 773 if (f != MOUNT_SUCCESS)
774 m->result = f;
e537352b 775
cd2086fe
LP		 776 r = unit_kill_context(
777 UNIT(m),
778 &m->kill_context,
db2cb23b
UTL		 779 (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
780 KILL_KILL : KILL_TERMINATE,
cd2086fe
LP		 781 -1,
782 m->control_pid,
783 false);
784 if (r < 0)
785 goto fail;
e537352b 786
cd2086fe 787 if (r > 0) {
718db961 788 r = mount_arm_timer(m);
36697dc0 789 if (r < 0)
80876c20 790 goto fail;
e537352b 791
80876c20 792 mount_set_state(m, state);
ac84d1fb
LP		 793 } else if (state == MOUNT_REMOUNTING_SIGTERM)
794 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
795 else if (state == MOUNT_REMOUNTING_SIGKILL)
9d2f5178 796 mount_enter_mounted(m, MOUNT_SUCCESS);
ac84d1fb
LP		 797 else if (state == MOUNT_MOUNTING_SIGTERM)
798 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
799 else if (state == MOUNT_UNMOUNTING_SIGTERM)
800 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
80876c20 801 else
9d2f5178 802 mount_enter_dead(m, MOUNT_SUCCESS);
e537352b
LP		 803
804 return;
805
806fail:
f2341e0a 807 log_unit_warning_errno(UNIT(m), r, "Failed to kill processes: %m");
e537352b 808
80876c20 809 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
9d2f5178 810 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
80876c20 811 else
9d2f5178 812 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
e537352b
LP		 813}
814
f2341e0a 815void unit_warn_if_dir_nonempty(Unit *u, const char* where) {
056edeb9
ZJS		 816 int r;
817
f2341e0a 818 assert(u);
cd2086fe
LP		 819 assert(where);
820
056edeb9
ZJS		 821 r = dir_is_empty(where);
822 if (r > 0)
20ad4cfd 823 return;
f2341e0a
LP		 824 if (r < 0) {
825 log_unit_warning_errno(u, r, "Failed to check directory %s: %m", where);
826 return;
827 }
828
829 log_struct(LOG_NOTICE,
830 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
831 LOG_UNIT_ID(u),
832 LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),
833 "WHERE=%s", where,
834 NULL);
20ad4cfd
ZJS		 835}
836
f2341e0a
LP		 837int unit_fail_if_symlink(Unit *u, const char* where) {
838 int r;
5261ba90 839
f2341e0a
LP		 840 assert(u);
841 assert(where);
5261ba90 842
f2341e0a
LP		 843 r = is_symlink(where);
844 if (r < 0) {
845 log_unit_debug_errno(u, r, "Failed to check symlink %s, ignoring: %m", where);
846 return 0;
5261ba90 847 }
f2341e0a
LP		 848 if (r == 0)
849 return 0;
850
851 log_struct(LOG_ERR,
852 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
853 LOG_UNIT_ID(u),
854 LOG_UNIT_MESSAGE(u, "Mount on symlink %s not allowed.", where),
855 "WHERE=%s", where,
856 NULL);
857
858 return -ELOOP;
5261ba90
TT		 859}
860
9d2f5178 861static void mount_enter_unmounting(Mount *m) {
e537352b
LP		 862 int r;
863
864 assert(m);
865
7d54a03a
LP		 866 /* Start counting our attempts */
867 if (!IN_SET(m->state,
868 MOUNT_UNMOUNTING,
869 MOUNT_UNMOUNTING_SIGTERM,
870 MOUNT_UNMOUNTING_SIGKILL))
871 m->n_retry_umount = 0;
872
a16e1123
LP		 873 m->control_command_id = MOUNT_EXEC_UNMOUNT;
874 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
e537352b 875
e86b3761
ZJS		 876 r = exec_command_set(m->control_command, "/bin/umount", m->where, NULL);
877 if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
878 r = exec_command_append(m->control_command, "-n", NULL);
7d54a03a 879 if (r < 0)
e537352b
LP		 880 goto fail;
881
a16e1123 882 mount_unwatch_control_pid(m);
5e94833f 883
7d54a03a
LP		 884 r = mount_spawn(m, m->control_command, &m->control_pid);
885 if (r < 0)
e537352b
LP		 886 goto fail;
887
888 mount_set_state(m, MOUNT_UNMOUNTING);
889
890 return;
891
892fail:
f2341e0a 893 log_unit_warning_errno(UNIT(m), r, "Failed to run 'umount' task: %m");
9d2f5178 894 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
e537352b
LP		 895}
896
8d567588 897static void mount_enter_mounting(Mount *m) {
e537352b 898 int r;
cb39ed3f 899 MountParameters *p;
e537352b
LP		 900
901 assert(m);
902
a16e1123
LP		 903 m->control_command_id = MOUNT_EXEC_MOUNT;
904 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
e537352b 905
f2341e0a
LP		 906 r = unit_fail_if_symlink(UNIT(m), m->where);
907 if (r < 0)
908 goto fail;
909
910 (void) mkdir_p_label(m->where, m->directory_mode);
3e5235b0 911
f2341e0a 912 unit_warn_if_dir_nonempty(UNIT(m), m->where);
257f1d8e 913
cb39ed3f 914 /* Create the source directory for bind-mounts if needed */
6b1dc2bd 915 p = get_mount_parameters_fragment(m);
cb39ed3f 916 if (p && mount_is_bind(p))
f2341e0a 917 (void) mkdir_p_label(p->what, m->directory_mode);
5261ba90 918
e86b3761 919 if (m->from_fragment) {
17a1c597
ZJS		 920 _cleanup_free_ char *opts = NULL;
921
922 r = fstab_filter_options(m->parameters_fragment.options,
76c37ab6 923 "nofail\0" "noauto\0" "auto\0", NULL, NULL, &opts);
17a1c597
ZJS		 924 if (r < 0)
925 goto fail;
926
e86b3761
ZJS		 927 r = exec_command_set(m->control_command, "/bin/mount",
928 m->parameters_fragment.what, m->where, NULL);
929 if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
930 r = exec_command_append(m->control_command, "-n", NULL);
931 if (r >= 0 && m->sloppy_options)
932 r = exec_command_append(m->control_command, "-s", NULL);
933 if (r >= 0 && m->parameters_fragment.fstype)
934 r = exec_command_append(m->control_command, "-t", m->parameters_fragment.fstype, NULL);
0c47569a 935 if (r >= 0 && !isempty(opts))
17a1c597 936 r = exec_command_append(m->control_command, "-o", opts, NULL);
e86b3761 937 } else
e537352b
LP		 938 r = -ENOENT;
939
940 if (r < 0)
941 goto fail;
942
a16e1123 943 mount_unwatch_control_pid(m);
5e94833f 944
257f1d8e
LP		 945 r = mount_spawn(m, m->control_command, &m->control_pid);
946 if (r < 0)
e537352b
LP		 947 goto fail;
948
949 mount_set_state(m, MOUNT_MOUNTING);
950
951 return;
952
953fail:
f2341e0a 954 log_unit_warning_errno(UNIT(m), r, "Failed to run 'mount' task: %m");
9d2f5178 955 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
e537352b
LP		 956}
957
9d2f5178 958static void mount_enter_remounting(Mount *m) {
e537352b
LP		 959 int r;
960
961 assert(m);
962
a16e1123
LP		 963 m->control_command_id = MOUNT_EXEC_REMOUNT;
964 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
e537352b
LP		 965
966 if (m->from_fragment) {
e537352b
LP		 967 const char *o;
968
718db961 969 if (m->parameters_fragment.options)
63c372cb 970 o = strjoina("remount,", m->parameters_fragment.options);
718db961 971 else
e537352b
LP		 972 o = "remount";
973
e86b3761
ZJS		 974 r = exec_command_set(m->control_command, "/bin/mount",
975 m->parameters_fragment.what, m->where,
976 "-o", o, NULL);
977 if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
978 r = exec_command_append(m->control_command, "-n", NULL);
979 if (r >= 0 && m->sloppy_options)
980 r = exec_command_append(m->control_command, "-s", NULL);
981 if (r >= 0 && m->parameters_fragment.fstype)
982 r = exec_command_append(m->control_command, "-t", m->parameters_fragment.fstype, NULL);
6b1dc2bd 983 } else
e537352b
LP		 984 r = -ENOENT;
985
60b912f6 986 if (r < 0)
e537352b 987 goto fail;
e537352b 988
a16e1123 989 mount_unwatch_control_pid(m);
5e94833f 990
718db961
LP		 991 r = mount_spawn(m, m->control_command, &m->control_pid);
992 if (r < 0)
e537352b
LP		 993 goto fail;
994
995 mount_set_state(m, MOUNT_REMOUNTING);
996
997 return;
998
999fail:
f2341e0a 1000 log_unit_warning_errno(UNIT(m), r, "Failed to run 'remount' task: %m");
9d2f5178
LP		 1001 m->reload_result = MOUNT_FAILURE_RESOURCES;
1002 mount_enter_mounted(m, MOUNT_SUCCESS);
e537352b
LP		 1003}
1004
1005static int mount_start(Unit *u) {
1006 Mount *m = MOUNT(u);
1007
1008 assert(m);
1009
1010 /* We cannot fulfill this request right now, try again later
1011 * please! */
1012 if (m->state == MOUNT_UNMOUNTING ||
1013 m->state == MOUNT_UNMOUNTING_SIGTERM ||
60b912f6
LP		 1014 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1015 m->state == MOUNT_MOUNTING_SIGTERM ||
1016 m->state == MOUNT_MOUNTING_SIGKILL)
e537352b
LP		 1017 return -EAGAIN;
1018
1019 /* Already on it! */
60b912f6 1020 if (m->state == MOUNT_MOUNTING)
e537352b
LP		 1021 return 0;
1022
fdf20a31 1023 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
e537352b 1024
9d2f5178
LP		 1025 m->result = MOUNT_SUCCESS;
1026 m->reload_result = MOUNT_SUCCESS;
5ad096b3 1027 m->reset_cpu_usage = true;
9d2f5178 1028
8d567588 1029 mount_enter_mounting(m);
82a2b6bb 1030 return 1;
e537352b
LP		 1031}
1032
1033static int mount_stop(Unit *u) {
1034 Mount *m = MOUNT(u);
1035
1036 assert(m);
1037
e537352b
LP		 1038 /* Already on it */
1039 if (m->state == MOUNT_UNMOUNTING ||
1040 m->state == MOUNT_UNMOUNTING_SIGKILL ||
60b912f6
LP		 1041 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1042 m->state == MOUNT_MOUNTING_SIGTERM ||
1043 m->state == MOUNT_MOUNTING_SIGKILL)
e537352b
LP		 1044 return 0;
1045
3f6c78dc
LP		 1046 assert(m->state == MOUNT_MOUNTING ||
1047 m->state == MOUNT_MOUNTING_DONE ||
1048 m->state == MOUNT_MOUNTED ||
3f6c78dc
LP		 1049 m->state == MOUNT_REMOUNTING ||
1050 m->state == MOUNT_REMOUNTING_SIGTERM ||
1051 m->state == MOUNT_REMOUNTING_SIGKILL);
e537352b 1052
9d2f5178 1053 mount_enter_unmounting(m);
82a2b6bb 1054 return 1;
e537352b
LP		 1055}
1056
1057static int mount_reload(Unit *u) {
1058 Mount *m = MOUNT(u);
1059
1060 assert(m);
1061
1062 if (m->state == MOUNT_MOUNTING_DONE)
1063 return -EAGAIN;
1064
1065 assert(m->state == MOUNT_MOUNTED);
1066
9d2f5178 1067 mount_enter_remounting(m);
e537352b
LP		 1068 return 0;
1069}
1070
a16e1123
LP		 1071static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1072 Mount *m = MOUNT(u);
1073
1074 assert(m);
1075 assert(f);
1076 assert(fds);
1077
1078 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
9d2f5178
LP		 1079 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1080 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
a16e1123
LP		 1081
1082 if (m->control_pid > 0)
ccd06097 1083 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
a16e1123
LP		 1084
1085 if (m->control_command_id >= 0)
1086 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1087
1088 return 0;
1089}
1090
1091static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1092 Mount *m = MOUNT(u);
a16e1123
LP		 1093
1094 assert(u);
1095 assert(key);
1096 assert(value);
1097 assert(fds);
1098
1099 if (streq(key, "state")) {
1100 MountState state;
1101
1102 if ((state = mount_state_from_string(value)) < 0)
f2341e0a 1103 log_unit_debug(u, "Failed to parse state value: %s", value);
a16e1123
LP		 1104 else
1105 m->deserialized_state = state;
9d2f5178
LP		 1106 } else if (streq(key, "result")) {
1107 MountResult f;
a16e1123 1108
9d2f5178
LP		 1109 f = mount_result_from_string(value);
1110 if (f < 0)
f2341e0a 1111 log_unit_debug(u, "Failed to parse result value: %s", value);
9d2f5178
LP		 1112 else if (f != MOUNT_SUCCESS)
1113 m->result = f;
1114
1115 } else if (streq(key, "reload-result")) {
1116 MountResult f;
1117
1118 f = mount_result_from_string(value);
1119 if (f < 0)
f2341e0a 1120 log_unit_debug(u, "Failed to parse reload result value: %s", value);
9d2f5178
LP		 1121 else if (f != MOUNT_SUCCESS)
1122 m->reload_result = f;
a16e1123
LP		 1123
1124 } else if (streq(key, "control-pid")) {
5925dd3c 1125 pid_t pid;
a16e1123 1126
e364ad06 1127 if (parse_pid(value, &pid) < 0)
f2341e0a 1128 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
a16e1123 1129 else
5925dd3c 1130 m->control_pid = pid;
a16e1123
LP		 1131 } else if (streq(key, "control-command")) {
1132 MountExecCommand id;
1133
f2341e0a
LP		 1134 id = mount_exec_command_from_string(value);
1135 if (id < 0)
1136 log_unit_debug(u, "Failed to parse exec-command value: %s", value);
a16e1123
LP		 1137 else {
1138 m->control_command_id = id;
1139 m->control_command = m->exec_command + id;
1140 }
a16e1123 1141 } else
f2341e0a 1142 log_unit_debug(u, "Unknown serialization key: %s", key);
a16e1123
LP		 1143
1144 return 0;
1145}
1146
44a6b1b6 1147_pure_ static UnitActiveState mount_active_state(Unit *u) {
e537352b
LP		 1148 assert(u);
1149
1150 return state_translation_table[MOUNT(u)->state];
1151}
1152
44a6b1b6 1153_pure_ static const char *mount_sub_state_to_string(Unit *u) {
10a94420
LP		 1154 assert(u);
1155
a16e1123 1156 return mount_state_to_string(MOUNT(u)->state);
10a94420
LP		 1157}
1158
44a6b1b6 1159_pure_ static bool mount_check_gc(Unit *u) {
701cc384
LP		 1160 Mount *m = MOUNT(u);
1161
1162 assert(m);
1163
6b1dc2bd 1164 return m->from_proc_self_mountinfo;
701cc384
LP		 1165}
1166
e537352b
LP		 1167static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1168 Mount *m = MOUNT(u);
9d2f5178 1169 MountResult f;
e537352b
LP		 1170
1171 assert(m);
1172 assert(pid >= 0);
1173
8c47c732
LP		 1174 if (pid != m->control_pid)
1175 return;
e537352b 1176
e537352b
LP		 1177 m->control_pid = 0;
1178
96342de6 1179 if (is_clean_exit(code, status, NULL))
9d2f5178
LP		 1180 f = MOUNT_SUCCESS;
1181 else if (code == CLD_EXITED)
1182 f = MOUNT_FAILURE_EXIT_CODE;
1183 else if (code == CLD_KILLED)
1184 f = MOUNT_FAILURE_SIGNAL;
1185 else if (code == CLD_DUMPED)
1186 f = MOUNT_FAILURE_CORE_DUMP;
1187 else
1188 assert_not_reached("Unknown code");
1189
1190 if (f != MOUNT_SUCCESS)
1191 m->result = f;
8c47c732 1192
a16e1123 1193 if (m->control_command) {
6ea832a2 1194 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
9d2f5178 1195
a16e1123
LP		 1196 m->control_command = NULL;
1197 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1198 }
1199
f2341e0a
LP		 1200 log_unit_full(u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
1201 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code), status);
e537352b
LP		 1202
1203 /* Note that mount(8) returning and the kernel sending us a
1204 * mount table change event might happen out-of-order. If an
1205 * operation succeed we assume the kernel will follow soon too
1206 * and already change into the resulting state. If it fails
1207 * we check if the kernel still knows about the mount. and
1208 * change state accordingly. */
1209
1210 switch (m->state) {
1211
1212 case MOUNT_MOUNTING:
1213 case MOUNT_MOUNTING_DONE:
1214 case MOUNT_MOUNTING_SIGKILL:
1215 case MOUNT_MOUNTING_SIGTERM:
e537352b 1216
9d2f5178
LP		 1217 if (f == MOUNT_SUCCESS)
1218 mount_enter_mounted(m, f);
e537352b 1219 else if (m->from_proc_self_mountinfo)
9d2f5178 1220 mount_enter_mounted(m, f);
e537352b 1221 else
9d2f5178 1222 mount_enter_dead(m, f);
e537352b
LP		 1223 break;
1224
e2f3b44c
LP		 1225 case MOUNT_REMOUNTING:
1226 case MOUNT_REMOUNTING_SIGKILL:
1227 case MOUNT_REMOUNTING_SIGTERM:
1228
9d2f5178 1229 m->reload_result = f;
e2f3b44c 1230 if (m->from_proc_self_mountinfo)
9d2f5178 1231 mount_enter_mounted(m, MOUNT_SUCCESS);
e2f3b44c 1232 else
9d2f5178 1233 mount_enter_dead(m, MOUNT_SUCCESS);
e2f3b44c
LP		 1234
1235 break;
1236
e537352b
LP		 1237 case MOUNT_UNMOUNTING:
1238 case MOUNT_UNMOUNTING_SIGKILL:
1239 case MOUNT_UNMOUNTING_SIGTERM:
1240
7d54a03a
LP		 1241 if (f == MOUNT_SUCCESS) {
1242
1243 if (m->from_proc_self_mountinfo) {
1244
1245 /* Still a mount point? If so, let's
1246 * try again. Most likely there were
1247 * multiple mount points stacked on
1248 * top of each other. Note that due to
1249 * the io event priority logic we can
1250 * be sure the new mountinfo is loaded
1251 * before we process the SIGCHLD for
1252 * the mount command. */
1253
1254 if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
f2341e0a 1255 log_unit_debug(u, "Mount still present, trying again.");
7d54a03a
LP		 1256 m->n_retry_umount++;
1257 mount_enter_unmounting(m);
1258 } else {
f2341e0a 1259 log_unit_debug(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
7d54a03a
LP		 1260 mount_enter_mounted(m, f);
1261 }
1262 } else
1263 mount_enter_dead(m, f);
1264
1265 } else if (m->from_proc_self_mountinfo)
9d2f5178 1266 mount_enter_mounted(m, f);
e537352b 1267 else
9d2f5178 1268 mount_enter_dead(m, f);
e537352b
LP		 1269 break;
1270
1271 default:
1272 assert_not_reached("Uh, control process died at wrong time.");
1273 }
c4e2ceae
LP		 1274
1275 /* Notify clients about changed exit status */
1276 unit_add_to_dbus_queue(u);
e537352b
LP		 1277}
1278
718db961
LP		 1279static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1280 Mount *m = MOUNT(userdata);
e537352b
LP		 1281
1282 assert(m);
718db961 1283 assert(m->timer_event_source == source);
e537352b
LP		 1284
1285 switch (m->state) {
1286
1287 case MOUNT_MOUNTING:
1288 case MOUNT_MOUNTING_DONE:
f2341e0a 1289 log_unit_warning(UNIT(m), "Mounting timed out. Stopping.");
9d2f5178 1290 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
e537352b
LP		 1291 break;
1292
1293 case MOUNT_REMOUNTING:
f2341e0a 1294 log_unit_warning(UNIT(m), "Remounting timed out. Stopping.");
9d2f5178
LP		 1295 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1296 mount_enter_mounted(m, MOUNT_SUCCESS);
e537352b
LP		 1297 break;
1298
1299 case MOUNT_UNMOUNTING:
f2341e0a 1300 log_unit_warning(UNIT(m), "Unmounting timed out. Stopping.");
9d2f5178 1301 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
e537352b
LP		 1302 break;
1303
1304 case MOUNT_MOUNTING_SIGTERM:
4819ff03 1305 if (m->kill_context.send_sigkill) {
f2341e0a 1306 log_unit_warning(UNIT(m), "Mounting timed out. Killing.");
9d2f5178 1307 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
ba035df2 1308 } else {
f2341e0a 1309 log_unit_warning(UNIT(m), "Mounting timed out. Skipping SIGKILL. Ignoring.");
ba035df2
LP		 1310
1311 if (m->from_proc_self_mountinfo)
9d2f5178 1312 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1313 else
9d2f5178 1314 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1315 }
e537352b
LP		 1316 break;
1317
1318 case MOUNT_REMOUNTING_SIGTERM:
4819ff03 1319 if (m->kill_context.send_sigkill) {
f2341e0a 1320 log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
9d2f5178 1321 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
ba035df2 1322 } else {
f2341e0a 1323 log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
ba035df2
LP		 1324
1325 if (m->from_proc_self_mountinfo)
9d2f5178 1326 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1327 else
9d2f5178 1328 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1329 }
e537352b
LP		 1330 break;
1331
1332 case MOUNT_UNMOUNTING_SIGTERM:
4819ff03 1333 if (m->kill_context.send_sigkill) {
f2341e0a 1334 log_unit_warning(UNIT(m), "Unmounting timed out. Killing.");
9d2f5178 1335 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
ba035df2 1336 } else {
f2341e0a 1337 log_unit_warning(UNIT(m), "Unmounting timed out. Skipping SIGKILL. Ignoring.");
ba035df2
LP		 1338
1339 if (m->from_proc_self_mountinfo)
9d2f5178 1340 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1341 else
9d2f5178 1342 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
ba035df2 1343 }
e537352b
LP		 1344 break;
1345
1346 case MOUNT_MOUNTING_SIGKILL:
1347 case MOUNT_REMOUNTING_SIGKILL:
1348 case MOUNT_UNMOUNTING_SIGKILL:
f2341e0a 1349 log_unit_warning(UNIT(m),"Mount process still around after SIGKILL. Ignoring.");
e537352b
LP		 1350
1351 if (m->from_proc_self_mountinfo)
9d2f5178 1352 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
e537352b 1353 else
9d2f5178 1354 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
e537352b
LP		 1355 break;
1356
1357 default:
1358 assert_not_reached("Timeout at wrong time.");
1359 }
718db961
LP		 1360
1361 return 0;
e537352b
LP		 1362}
1363
628c89cc 1364static int mount_setup_unit(
e537352b
LP		 1365 Manager *m,
1366 const char *what,
1367 const char *where,
1368 const char *options,
1369 const char *fstype,
e537352b 1370 bool set_flags) {
057d9ab8
LP		 1371
1372 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
b87705cd 1373 bool load_extras = false;
057d9ab8 1374 MountParameters *p;
ff5f34d0 1375 bool delete, changed = false;
057d9ab8
LP		 1376 Unit *u;
1377 int r;
b08d03ff 1378
f50e0a01 1379 assert(m);
b08d03ff
LP		 1380 assert(what);
1381 assert(where);
e537352b
LP		 1382 assert(options);
1383 assert(fstype);
1384
e537352b
LP		 1385 /* Ignore API mount points. They should never be referenced in
1386 * dependencies ever. */
33ff02c9 1387 if (mount_point_is_api(where) || mount_point_ignore(where))
57f2a956 1388 return 0;
b08d03ff 1389
8d567588
LP		 1390 if (streq(fstype, "autofs"))
1391 return 0;
1392
4e85aff4
LP		 1393 /* probably some kind of swap, ignore */
1394 if (!is_path(where))
b08d03ff
LP		 1395 return 0;
1396
7410616c
LP		 1397 r = unit_name_from_path(where, ".mount", &e);
1398 if (r < 0)
1399 return r;
b08d03ff 1400
7d17cfbc
MS		 1401 u = manager_get_unit(m, e);
1402 if (!u) {
b08d03ff
LP		 1403 delete = true;
1404
7d17cfbc 1405 u = unit_new(m, sizeof(Mount));
057d9ab8 1406 if (!u)
628c89cc 1407 return log_oom();
b08d03ff
LP		 1408
1409 r = unit_add_name(u, e);
b08d03ff
LP		 1410 if (r < 0)
1411 goto fail;
1412
7d17cfbc
MS		 1413 MOUNT(u)->where = strdup(where);
1414 if (!MOUNT(u)->where) {
07b0b134
ML		 1415 r = -ENOMEM;
1416 goto fail;
1417 }
f50e0a01 1418
47a81ba2
UTL		 1419 u->source_path = strdup("/proc/self/mountinfo");
1420 if (!u->source_path) {
1421 r = -ENOMEM;
1422 goto fail;
1423 }
1424
057d9ab8
LP		 1425 if (m->running_as == SYSTEMD_SYSTEM) {
1426 const char* target;
1427
affc3d83 1428 target = mount_needs_network(options, fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
057d9ab8 1429 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
602c0e74
LP		 1430 if (r < 0)
1431 goto fail;
057d9ab8
LP		 1432
1433 if (should_umount(MOUNT(u))) {
1434 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1435 if (r < 0)
1436 goto fail;
1437 }
602c0e74 1438 }
89b1d5e0 1439
f94ea366 1440 unit_add_to_load_queue(u);
ff5f34d0 1441 changed = true;
b08d03ff
LP		 1442 } else {
1443 delete = false;
8eba616f 1444
bcbd5405
WW		 1445 if (!MOUNT(u)->where) {
1446 MOUNT(u)->where = strdup(where);
1447 if (!MOUNT(u)->where) {
1448 r = -ENOMEM;
1449 goto fail;
1450 }
1451 }
1452
9d05dd2e
ZJS		 1453 if (m->running_as == SYSTEMD_SYSTEM &&
1454 mount_needs_network(options, fstype)) {
a6d305f9
CL		 1455 /* _netdev option may have shown up late, or on a
1456 * remount. Add remote-fs dependencies, even though
9d05dd2e
ZJS		 1457 * local-fs ones may already be there. */
1458 unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true);
1459 load_extras = true;
a6d305f9
CL		 1460 }
1461
c2756a68 1462 if (u->load_state == UNIT_NOT_FOUND) {
8eba616f
MS		 1463 u->load_state = UNIT_LOADED;
1464 u->load_error = 0;
b87705cd
LP		 1465
1466 /* Load in the extras later on, after we
1467 * finished initialization of the unit */
1468 load_extras = true;
ff5f34d0 1469 changed = true;
8eba616f 1470 }
b08d03ff
LP		 1471 }
1472
dd7a22a9
LP		 1473 w = strdup(what);
1474 o = strdup(options);
1475 f = strdup(fstype);
1476 if (!w || !o || !f) {
e537352b
LP		 1477 r = -ENOMEM;
1478 goto fail;
1479 }
1480
6b1dc2bd 1481 p = &MOUNT(u)->parameters_proc_self_mountinfo;
ff5f34d0
LP		 1482
1483 changed = changed ||
1484 !streq_ptr(p->options, options) ||
1485 !streq_ptr(p->what, what) ||
1486 !streq_ptr(p->fstype, fstype);
1487
6b1dc2bd
LP		 1488 if (set_flags) {
1489 MOUNT(u)->is_mounted = true;
1490 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
ff5f34d0 1491 MOUNT(u)->just_changed = changed;
ef734fd6 1492 }
f50e0a01 1493
6b1dc2bd
LP		 1494 MOUNT(u)->from_proc_self_mountinfo = true;
1495
4e85aff4
LP		 1496 free(p->what);
1497 p->what = w;
057d9ab8 1498 w = NULL;
b08d03ff 1499
4e85aff4
LP		 1500 free(p->options);
1501 p->options = o;
057d9ab8 1502 o = NULL;
e537352b 1503
4e85aff4
LP		 1504 free(p->fstype);
1505 p->fstype = f;
057d9ab8 1506 f = NULL;
b08d03ff 1507
b87705cd
LP		 1508 if (load_extras) {
1509 r = mount_add_extras(MOUNT(u));
1510 if (r < 0)
1511 goto fail;
1512 }
1513
ff5f34d0
LP		 1514 if (changed)
1515 unit_add_to_dbus_queue(u);
c1e1601e 1516
b08d03ff
LP		 1517 return 0;
1518
1519fail:
628c89cc
LP		 1520 log_warning_errno(r, "Failed to set up mount unit: %m");
1521
b08d03ff
LP		 1522 if (delete && u)
1523 unit_free(u);
1524
4e85aff4 1525 return r;
b08d03ff
LP		 1526}
1527
ef734fd6 1528static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
628c89cc
LP		 1529 _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
1530 _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
60b912f6 1531 int r = 0;
b08d03ff
LP		 1532
1533 assert(m);
1534
628c89cc
LP		 1535 t = mnt_new_table();
1536 if (!t)
8d3ae2bd 1537 return log_oom();
b08d03ff 1538
628c89cc
LP		 1539 i = mnt_new_iter(MNT_ITER_FORWARD);
1540 if (!i)
1541 return log_oom();
1542
1543 r = mnt_table_parse_mtab(t, NULL);
5cca8def 1544 if (r < 0)
628c89cc 1545 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
e537352b 1546
5cca8def
ZJS		 1547 r = 0;
1548 for (;;) {
8d3ae2bd 1549 const char *device, *path, *options, *fstype;
527b7a42 1550 _cleanup_free_ char *d = NULL, *p = NULL;
628c89cc 1551 struct libmnt_fs *fs;
8d3ae2bd 1552 int k;
b08d03ff 1553
628c89cc 1554 k = mnt_table_next_fs(t, i, &fs);
5cca8def
ZJS		 1555 if (k == 1)
1556 break;
628c89cc
LP		 1557 if (k < 0)
1558 return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
5cca8def 1559
8d3ae2bd
CL		 1560 device = mnt_fs_get_source(fs);
1561 path = mnt_fs_get_target(fs);
1562 options = mnt_fs_get_options(fs);
1563 fstype = mnt_fs_get_fstype(fs);
a2e0f3d3 1564
527b7a42 1565 if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
628c89cc
LP		 1566 return log_oom();
1567
527b7a42 1568 if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
a57f7e2c 1569 return log_oom();
b08d03ff 1570
628c89cc
LP		 1571 (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
1572
1573 k = mount_setup_unit(m, d, p, options, fstype, set_flags);
5cca8def 1574 if (r == 0 && k < 0)
60b912f6 1575 r = k;
b08d03ff
LP		 1576 }
1577
e537352b
LP		 1578 return r;
1579}
1580
1581static void mount_shutdown(Manager *m) {
1582 assert(m);
1583
718db961 1584 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
befb6d54 1585 m->mount_utab_event_source = sd_event_source_unref(m->mount_utab_event_source);
718db961 1586
a16e1123 1587 if (m->proc_self_mountinfo) {
e537352b 1588 fclose(m->proc_self_mountinfo);
a16e1123
LP		 1589 m->proc_self_mountinfo = NULL;
1590 }
befb6d54 1591 m->utab_inotify_fd = safe_close(m->utab_inotify_fd);
b08d03ff
LP		 1592}
1593
68db7a3b
ZJS		 1594static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1595 Mount *m = MOUNT(u);
1596 int r;
1597
1598 if (!m->timer_event_source)
1599 return 0;
1600
1601 r = sd_event_source_get_time(m->timer_event_source, timeout);
1602 if (r < 0)
1603 return r;
1604
1605 return 1;
1606}
1607
b08d03ff
LP		 1608static int mount_enumerate(Manager *m) {
1609 int r;
1610 assert(m);
1611
8d3ae2bd
CL		 1612 mnt_init_debug(0);
1613
a16e1123 1614 if (!m->proc_self_mountinfo) {
e62d8c39
ZJS		 1615 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1616 if (!m->proc_self_mountinfo)
a16e1123 1617 return -errno;
ef734fd6 1618
151b9b96 1619 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
718db961
LP		 1620 if (r < 0)
1621 goto fail;
29083707
LP		 1622
1623 /* Dispatch this before we dispatch SIGCHLD, so that
1624 * we always get the events from /proc/self/mountinfo
1625 * before the SIGCHLD of /bin/mount. */
1626 r = sd_event_source_set_priority(m->mount_event_source, -10);
1627 if (r < 0)
1628 goto fail;
7dfbe2e3
TG		 1629
1630 (void) sd_event_source_set_description(m->mount_event_source, "mount-mountinfo-dispatch");
a16e1123 1631 }
ef734fd6 1632
befb6d54
CL		 1633 if (m->utab_inotify_fd < 0) {
1634 m->utab_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
f7c1ad4f
LP		 1635 if (m->utab_inotify_fd < 0) {
1636 r = -errno;
1637 goto fail;
1638 }
befb6d54 1639
90598531
ZJS		 1640 (void) mkdir_p_label("/run/mount", 0755);
1641
befb6d54 1642 r = inotify_add_watch(m->utab_inotify_fd, "/run/mount", IN_MOVED_TO);
f7c1ad4f
LP		 1643 if (r < 0) {
1644 r = -errno;
1645 goto fail;
1646 }
befb6d54
CL		 1647
1648 r = sd_event_add_io(m->event, &m->mount_utab_event_source, m->utab_inotify_fd, EPOLLIN, mount_dispatch_io, m);
1649 if (r < 0)
1650 goto fail;
1651
1652 r = sd_event_source_set_priority(m->mount_utab_event_source, -10);
1653 if (r < 0)
1654 goto fail;
7dfbe2e3
TG		 1655
1656 (void) sd_event_source_set_description(m->mount_utab_event_source, "mount-utab-dispatch");
befb6d54
CL		 1657 }
1658
e62d8c39
ZJS		 1659 r = mount_load_proc_self_mountinfo(m, false);
1660 if (r < 0)
b08d03ff
LP		 1661 goto fail;
1662
1663 return 0;
1664
1665fail:
1666 mount_shutdown(m);
1667 return r;
5cb5a6ff
LP		 1668}
1669
718db961
LP		 1670static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1671 Manager *m = userdata;
595ed347 1672 Unit *u;
ef734fd6
LP		 1673 int r;
1674
1675 assert(m);
befb6d54 1676 assert(revents & (EPOLLPRI | EPOLLIN));
ef734fd6
LP		 1677
1678 /* The manager calls this for every fd event happening on the
1679 * /proc/self/mountinfo file, which informs us about mounting
fddf1a31
ZJS		 1680 * table changes, and for /run/mount events which we watch
1681 * for mount options. */
befb6d54
CL		 1682
1683 if (fd == m->utab_inotify_fd) {
df63dda6 1684 bool rescan = false;
befb6d54 1685
b7307642
LP		 1686 /* FIXME: We *really* need to replace this with
1687 * libmount's own API for this, we should not hardcode
1688 * internal behaviour of libmount here. */
1689
f7c1ad4f 1690 for (;;) {
0254e944 1691 union inotify_event_buffer buffer;
f7c1ad4f
LP		 1692 struct inotify_event *e;
1693 ssize_t l;
1694
0254e944 1695 l = read(fd, &buffer, sizeof(buffer));
f7c1ad4f
LP		 1696 if (l < 0) {
1697 if (errno == EAGAIN || errno == EINTR)
1698 break;
1699
1700 log_error_errno(errno, "Failed to read utab inotify: %m");
1701 break;
1702 }
1703
1704 FOREACH_INOTIFY_EVENT(e, buffer, l) {
1705 /* Only care about changes to utab,
1706 * but we have to monitor the
1707 * directory to reliably get
1708 * notifications about when utab is
1709 * replaced using rename(2) */
1710 if ((e->mask & IN_Q_OVERFLOW) || streq(e->name, "utab"))
df63dda6 1711 rescan = true;
befb6d54 1712 }
f7c1ad4f 1713 }
fddf1a31 1714
befb6d54
CL		 1715 if (!rescan)
1716 return 0;
1717 }
ef734fd6 1718
4f0eedb7
ZJS		 1719 r = mount_load_proc_self_mountinfo(m, true);
1720 if (r < 0) {
e537352b 1721 /* Reset flags, just in case, for later calls */
595ed347
MS		 1722 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1723 Mount *mount = MOUNT(u);
e537352b
LP		 1724
1725 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1726 }
1727
718db961 1728 return 0;
ef734fd6
LP		 1729 }
1730
1731 manager_dispatch_load_queue(m);
1732
595ed347
MS		 1733 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1734 Mount *mount = MOUNT(u);
ef734fd6 1735
e537352b 1736 if (!mount->is_mounted) {
e537352b 1737
ef734fd6 1738 mount->from_proc_self_mountinfo = false;
e537352b
LP		 1739
1740 switch (mount->state) {
1741
1742 case MOUNT_MOUNTED:
aef83136
LP		 1743 /* This has just been unmounted by
1744 * somebody else, follow the state
1745 * change. */
9d2f5178 1746 mount_enter_dead(mount, MOUNT_SUCCESS);
e537352b
LP		 1747 break;
1748
1749 default:
e537352b 1750 break;
e537352b
LP		 1751 }
1752
628c89cc
LP		 1753 if (mount->parameters_proc_self_mountinfo.what)
1754 (void) device_found_node(m, mount->parameters_proc_self_mountinfo.what, false, DEVICE_FOUND_MOUNT, true);
1755
1756
e537352b
LP		 1757 } else if (mount->just_mounted || mount->just_changed) {
1758
60b912f6 1759 /* New or changed mount entry */
e537352b
LP		 1760
1761 switch (mount->state) {
1762
1763 case MOUNT_DEAD:
fdf20a31 1764 case MOUNT_FAILED:
aef83136
LP		 1765 /* This has just been mounted by
1766 * somebody else, follow the state
1767 * change. */
9d2f5178 1768 mount_enter_mounted(mount, MOUNT_SUCCESS);
e537352b
LP		 1769 break;
1770
1771 case MOUNT_MOUNTING:
5bcb0f2b 1772 mount_set_state(mount, MOUNT_MOUNTING_DONE);
e537352b
LP		 1773 break;
1774
1775 default:
1776 /* Nothing really changed, but let's
1777 * issue an notification call
1778 * nonetheless, in case somebody is
1779 * waiting for this. (e.g. file system
1780 * ro/rw remounts.) */
1781 mount_set_state(mount, mount->state);
1782 break;
1783 }
1784 }
1785
1786 /* Reset the flags for later calls */
1787 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1788 }
718db961
LP		 1789
1790 return 0;
e537352b
LP		 1791}
1792
fdf20a31 1793static void mount_reset_failed(Unit *u) {
5632e374
LP		 1794 Mount *m = MOUNT(u);
1795
1796 assert(m);
1797
fdf20a31 1798 if (m->state == MOUNT_FAILED)
5632e374
LP		 1799 mount_set_state(m, MOUNT_DEAD);
1800
9d2f5178
LP		 1801 m->result = MOUNT_SUCCESS;
1802 m->reload_result = MOUNT_SUCCESS;
5632e374
LP		 1803}
1804
718db961 1805static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
814cc562 1806 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
8a0867d6
LP		 1807}
1808
a16e1123
LP		 1809static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1810 [MOUNT_DEAD] = "dead",
1811 [MOUNT_MOUNTING] = "mounting",
1812 [MOUNT_MOUNTING_DONE] = "mounting-done",
1813 [MOUNT_MOUNTED] = "mounted",
1814 [MOUNT_REMOUNTING] = "remounting",
1815 [MOUNT_UNMOUNTING] = "unmounting",
1816 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1817 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1818 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1819 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1820 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1821 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
fdf20a31 1822 [MOUNT_FAILED] = "failed"
a16e1123
LP		 1823};
1824
1825DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1826
1827static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1828 [MOUNT_EXEC_MOUNT] = "ExecMount",
1829 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1830 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1831};
1832
1833DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1834
9d2f5178
LP		 1835static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1836 [MOUNT_SUCCESS] = "success",
1837 [MOUNT_FAILURE_RESOURCES] = "resources",
1838 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1839 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1840 [MOUNT_FAILURE_SIGNAL] = "signal",
1841 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1842};
1843
1844DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1845
87f0e418 1846const UnitVTable mount_vtable = {
7d17cfbc 1847 .object_size = sizeof(Mount),
718db961
LP		 1848 .exec_context_offset = offsetof(Mount, exec_context),
1849 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1850 .kill_context_offset = offsetof(Mount, kill_context),
613b411c 1851 .exec_runtime_offset = offsetof(Mount, exec_runtime),
3ef63c31 1852
f975e971
LP		 1853 .sections =
1854 "Unit\0"
1855 "Mount\0"
1856 "Install\0",
4ad49000 1857 .private_section = "Mount",
71645aca 1858
e537352b 1859 .no_alias = true,
9e2f7c11 1860 .no_instances = true,
e537352b
LP		 1861
1862 .init = mount_init,
1863 .load = mount_load,
034c6ed7 1864 .done = mount_done,
e537352b 1865
f50e0a01
LP		 1866 .coldplug = mount_coldplug,
1867
034c6ed7 1868 .dump = mount_dump,
5cb5a6ff 1869
e537352b
LP		 1870 .start = mount_start,
1871 .stop = mount_stop,
1872 .reload = mount_reload,
1873
8a0867d6
LP		 1874 .kill = mount_kill,
1875
a16e1123
LP		 1876 .serialize = mount_serialize,
1877 .deserialize_item = mount_deserialize_item,
1878
f50e0a01 1879 .active_state = mount_active_state,
10a94420 1880 .sub_state_to_string = mount_sub_state_to_string,
b08d03ff 1881
701cc384
LP		 1882 .check_gc = mount_check_gc,
1883
e537352b 1884 .sigchld_event = mount_sigchld_event,
e537352b 1885
fdf20a31 1886 .reset_failed = mount_reset_failed,
5632e374 1887
c4e2ceae 1888 .bus_interface = "org.freedesktop.systemd1.Mount",
718db961 1889 .bus_vtable = bus_mount_vtable,
74c964d3
LP		 1890 .bus_set_property = bus_mount_set_property,
1891 .bus_commit_properties = bus_mount_commit_properties,
4139c1b2 1892
68db7a3b
ZJS		 1893 .get_timeout = mount_get_timeout,
1894
0e252f6b
TG		 1895 .can_transient = true,
1896
f50e0a01 1897 .enumerate = mount_enumerate,
c6918296
MS		 1898 .shutdown = mount_shutdown,
1899
1900 .status_message_formats = {
1901 .starting_stopping = {
1902 [0] = "Mounting %s...",
1903 [1] = "Unmounting %s...",
1904 },
1905 .finished_start_job = {
1906 [JOB_DONE] = "Mounted %s.",
1907 [JOB_FAILED] = "Failed to mount %s.",
1908 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1909 [JOB_TIMEOUT] = "Timed out mounting %s.",
1910 },
1911 .finished_stop_job = {
1912 [JOB_DONE] = "Unmounted %s.",
1913 [JOB_FAILED] = "Failed unmounting %s.",
1914 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1915 },
1916 },
5cb5a6ff 1917};
Unnamed repository; edit this file 'description' to name the repository.