]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/mount.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #8077 from sourcejedi/seccomp_cosmetic
[thirdparty/systemd.git] / src / core / mount.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2010 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <errno.h>
22 #include <signal.h>
23 #include <stdio.h>
24 #include <sys/epoll.h>
25
26 #include "sd-messages.h"
27
28 #include "alloc-util.h"
29 #include "dbus-mount.h"
30 #include "escape.h"
31 #include "exit-status.h"
32 #include "format-util.h"
33 #include "fstab-util.h"
34 #include "log.h"
35 #include "manager.h"
36 #include "mkdir.h"
37 #include "mount-setup.h"
38 #include "mount-util.h"
39 #include "mount.h"
40 #include "parse-util.h"
41 #include "path-util.h"
42 #include "process-util.h"
43 #include "special.h"
44 #include "string-table.h"
45 #include "string-util.h"
46 #include "strv.h"
47 #include "unit-name.h"
48 #include "unit.h"
49
50 #define RETRY_UMOUNT_MAX 32
51
52 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
53 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
54
55 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
56 [MOUNT_DEAD] = UNIT_INACTIVE,
57 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
58 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVATING,
59 [MOUNT_MOUNTED] = UNIT_ACTIVE,
60 [MOUNT_REMOUNTING] = UNIT_RELOADING,
61 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
62 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
63 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
64 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
65 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
66 [MOUNT_FAILED] = UNIT_FAILED
67 };
68
69 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
70 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
71
72 static bool MOUNT_STATE_WITH_PROCESS(MountState state) {
73 return IN_SET(state,
74 MOUNT_MOUNTING,
75 MOUNT_MOUNTING_DONE,
76 MOUNT_REMOUNTING,
77 MOUNT_REMOUNTING_SIGTERM,
78 MOUNT_REMOUNTING_SIGKILL,
79 MOUNT_UNMOUNTING,
80 MOUNT_UNMOUNTING_SIGTERM,
81 MOUNT_UNMOUNTING_SIGKILL);
82 }
83
84 static bool mount_needs_network(const char *options, const char *fstype) {
85 if (fstab_test_option(options, "_netdev\0"))
86 return true;
87
88 if (fstype && fstype_is_network(fstype))
89 return true;
90
91 return false;
92 }
93
94 static bool mount_is_network(const MountParameters *p) {
95 assert(p);
96
97 return mount_needs_network(p->options, p->fstype);
98 }
99
100 static bool mount_is_loop(const MountParameters *p) {
101 assert(p);
102
103 if (fstab_test_option(p->options, "loop\0"))
104 return true;
105
106 return false;
107 }
108
109 static bool mount_is_bind(const MountParameters *p) {
110 assert(p);
111
112 if (fstab_test_option(p->options, "bind\0" "rbind\0"))
113 return true;
114
115 if (p->fstype && STR_IN_SET(p->fstype, "bind", "rbind"))
116 return true;
117
118 return false;
119 }
120
121 static bool mount_is_auto(const MountParameters *p) {
122 assert(p);
123
124 return !fstab_test_option(p->options, "noauto\0");
125 }
126
127 static bool mount_is_automount(const MountParameters *p) {
128 assert(p);
129
130 return fstab_test_option(p->options,
131 "comment=systemd.automount\0"
132 "x-systemd.automount\0");
133 }
134
135 static bool mount_is_bound_to_device(const Mount *m) {
136 const MountParameters *p;
137
138 if (m->from_fragment)
139 return true;
140
141 p = &m->parameters_proc_self_mountinfo;
142 return fstab_test_option(p->options, "x-systemd.device-bound\0");
143 }
144
145 static bool needs_quota(const MountParameters *p) {
146 assert(p);
147
148 /* Quotas are not enabled on network filesystems,
149 * but we want them, for example, on storage connected via iscsi */
150 if (p->fstype && fstype_is_network(p->fstype))
151 return false;
152
153 if (mount_is_bind(p))
154 return false;
155
156 return fstab_test_option(p->options,
157 "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
158 }
159
160 static void mount_init(Unit *u) {
161 Mount *m = MOUNT(u);
162
163 assert(u);
164 assert(u->load_state == UNIT_STUB);
165
166 m->timeout_usec = u->manager->default_timeout_start_usec;
167
168 m->exec_context.std_output = u->manager->default_std_output;
169 m->exec_context.std_error = u->manager->default_std_error;
170
171 m->directory_mode = 0755;
172
173 /* We need to make sure that /usr/bin/mount is always called
174 * in the same process group as us, so that the autofs kernel
175 * side doesn't send us another mount request while we are
176 * already trying to comply its last one. */
177 m->exec_context.same_pgrp = true;
178
179 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
180
181 u->ignore_on_isolate = true;
182 }
183
184 static int mount_arm_timer(Mount *m, usec_t usec) {
185 int r;
186
187 assert(m);
188
189 if (m->timer_event_source) {
190 r = sd_event_source_set_time(m->timer_event_source, usec);
191 if (r < 0)
192 return r;
193
194 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
195 }
196
197 if (usec == USEC_INFINITY)
198 return 0;
199
200 r = sd_event_add_time(
201 UNIT(m)->manager->event,
202 &m->timer_event_source,
203 CLOCK_MONOTONIC,
204 usec, 0,
205 mount_dispatch_timer, m);
206 if (r < 0)
207 return r;
208
209 (void) sd_event_source_set_description(m->timer_event_source, "mount-timer");
210
211 return 0;
212 }
213
214 static void mount_unwatch_control_pid(Mount *m) {
215 assert(m);
216
217 if (m->control_pid <= 0)
218 return;
219
220 unit_unwatch_pid(UNIT(m), m->control_pid);
221 m->control_pid = 0;
222 }
223
224 static void mount_parameters_done(MountParameters *p) {
225 assert(p);
226
227 free(p->what);
228 free(p->options);
229 free(p->fstype);
230
231 p->what = p->options = p->fstype = NULL;
232 }
233
234 static void mount_done(Unit *u) {
235 Mount *m = MOUNT(u);
236
237 assert(m);
238
239 m->where = mfree(m->where);
240
241 mount_parameters_done(&m->parameters_proc_self_mountinfo);
242 mount_parameters_done(&m->parameters_fragment);
243
244 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
245 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
246 m->control_command = NULL;
247
248 dynamic_creds_unref(&m->dynamic_creds);
249
250 mount_unwatch_control_pid(m);
251
252 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
253 }
254
255 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
256 assert(m);
257
258 if (m->from_fragment)
259 return &m->parameters_fragment;
260
261 return NULL;
262 }
263
264 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
265 assert(m);
266
267 if (m->from_proc_self_mountinfo)
268 return &m->parameters_proc_self_mountinfo;
269
270 return get_mount_parameters_fragment(m);
271 }
272
273 static int mount_add_mount_dependencies(Mount *m) {
274 MountParameters *pm;
275 Unit *other;
276 Iterator i;
277 Set *s;
278 int r;
279
280 assert(m);
281
282 if (!path_equal(m->where, "/")) {
283 _cleanup_free_ char *parent = NULL;
284
285 /* Adds in links to other mount points that might lie further up in the hierarchy */
286
287 parent = dirname_malloc(m->where);
288 if (!parent)
289 return -ENOMEM;
290
291 r = unit_require_mounts_for(UNIT(m), parent, UNIT_DEPENDENCY_IMPLICIT);
292 if (r < 0)
293 return r;
294 }
295
296 /* Adds in dependencies to other mount points that might be needed for the source path (if this is a bind mount
297 * or a loop mount) to be available. */
298 pm = get_mount_parameters_fragment(m);
299 if (pm && pm->what &&
300 path_is_absolute(pm->what) &&
301 (mount_is_bind(pm) || mount_is_loop(pm) || !mount_is_network(pm))) {
302
303 r = unit_require_mounts_for(UNIT(m), pm->what, UNIT_DEPENDENCY_FILE);
304 if (r < 0)
305 return r;
306 }
307
308 /* Adds in dependencies to other units that use this path or paths further down in the hierarchy */
309 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
310 SET_FOREACH(other, s, i) {
311
312 if (other->load_state != UNIT_LOADED)
313 continue;
314
315 if (other == UNIT(m))
316 continue;
317
318 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true, UNIT_DEPENDENCY_PATH);
319 if (r < 0)
320 return r;
321
322 if (UNIT(m)->fragment_path) {
323 /* If we have fragment configuration, then make this dependency required */
324 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true, UNIT_DEPENDENCY_PATH);
325 if (r < 0)
326 return r;
327 }
328 }
329
330 return 0;
331 }
332
333 static int mount_add_device_dependencies(Mount *m) {
334 bool device_wants_mount = false;
335 UnitDependencyMask mask;
336 MountParameters *p;
337 UnitDependency dep;
338 int r;
339
340 assert(m);
341
342 p = get_mount_parameters(m);
343 if (!p)
344 return 0;
345
346 if (!p->what)
347 return 0;
348
349 if (mount_is_bind(p))
350 return 0;
351
352 if (!is_device_path(p->what))
353 return 0;
354
355 /* /dev/root is a really weird thing, it's not a real device,
356 * but just a path the kernel exports for the root file system
357 * specified on the kernel command line. Ignore it here. */
358 if (path_equal(p->what, "/dev/root"))
359 return 0;
360
361 if (path_equal(m->where, "/"))
362 return 0;
363
364 if (mount_is_auto(p) && !mount_is_automount(p) && MANAGER_IS_SYSTEM(UNIT(m)->manager))
365 device_wants_mount = true;
366
367 /* Mount units from /proc/self/mountinfo are not bound to devices
368 * by default since they're subject to races when devices are
369 * unplugged. But the user can still force this dep with an
370 * appropriate option (or udev property) so the mount units are
371 * automatically stopped when the device disappears suddenly. */
372 dep = mount_is_bound_to_device(m) ? UNIT_BINDS_TO : UNIT_REQUIRES;
373
374 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
375
376 r = unit_add_node_dependency(UNIT(m), p->what, device_wants_mount, dep, mask);
377 if (r < 0)
378 return r;
379
380 return 0;
381 }
382
383 static int mount_add_quota_dependencies(Mount *m) {
384 UnitDependencyMask mask;
385 MountParameters *p;
386 int r;
387
388 assert(m);
389
390 if (!MANAGER_IS_SYSTEM(UNIT(m)->manager))
391 return 0;
392
393 p = get_mount_parameters_fragment(m);
394 if (!p)
395 return 0;
396
397 if (!needs_quota(p))
398 return 0;
399
400 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
401
402 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true, mask);
403 if (r < 0)
404 return r;
405
406 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true, mask);
407 if (r < 0)
408 return r;
409
410 return 0;
411 }
412
413 static bool mount_is_extrinsic(Mount *m) {
414 MountParameters *p;
415 assert(m);
416
417 /* Returns true for all units that are "magic" and should be excluded from the usual start-up and shutdown
418 * dependencies. We call them "extrinsic" here, as they are generally mounted outside of the systemd dependency
419 * logic. We shouldn't attempt to manage them ourselves but it's fine if the user operates on them with us. */
420
421 if (!MANAGER_IS_SYSTEM(UNIT(m)->manager)) /* We only automatically manage mounts if we are in system mode */
422 return true;
423
424 if (PATH_IN_SET(m->where, /* Don't bother with the OS data itself */
425 "/",
426 "/usr"))
427 return true;
428
429 if (PATH_STARTSWITH_SET(m->where,
430 "/run/initramfs", /* This should stay around from before we boot until after we shutdown */
431 "/proc", /* All of this is API VFS */
432 "/sys", /* … dito … */
433 "/dev")) /* … dito … */
434 return true;
435
436 /* If this is an initrd mount, and we are not in the initrd, then leave this around forever, too. */
437 p = get_mount_parameters(m);
438 if (p && fstab_test_option(p->options, "x-initrd.mount\0") && !in_initrd())
439 return true;
440
441 return false;
442 }
443
444 static int mount_add_default_dependencies(Mount *m) {
445 UnitDependencyMask mask;
446 int r;
447 MountParameters *p;
448 const char *after;
449
450 assert(m);
451
452 if (!UNIT(m)->default_dependencies)
453 return 0;
454
455 /* We do not add any default dependencies to /, /usr or /run/initramfs/, since they are guaranteed to stay
456 * mounted the whole time, since our system is on it. Also, don't bother with anything mounted below virtual
457 * file systems, it's also going to be virtual, and hence not worth the effort. */
458 if (mount_is_extrinsic(m))
459 return 0;
460
461 p = get_mount_parameters(m);
462 if (!p)
463 return 0;
464
465 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_DEFAULT;
466
467 if (mount_is_network(p)) {
468 /* We order ourselves after network.target. This is
469 * primarily useful at shutdown: services that take
470 * down the network should order themselves before
471 * network.target, so that they are shut down only
472 * after this mount unit is stopped. */
473
474 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_NETWORK_TARGET, NULL, true, mask);
475 if (r < 0)
476 return r;
477
478 /* We pull in network-online.target, and order
479 * ourselves after it. This is useful at start-up to
480 * actively pull in tools that want to be started
481 * before we start mounting network file systems, and
482 * whose purpose it is to delay this until the network
483 * is "up". */
484
485 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, SPECIAL_NETWORK_ONLINE_TARGET, NULL, true, mask);
486 if (r < 0)
487 return r;
488
489 after = SPECIAL_REMOTE_FS_PRE_TARGET;
490 } else
491 after = SPECIAL_LOCAL_FS_PRE_TARGET;
492
493 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true, mask);
494 if (r < 0)
495 return r;
496
497 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, mask);
498 if (r < 0)
499 return r;
500
501 /* If this is a tmpfs mount then we have to unmount it before we try to deactivate swaps */
502 if (streq_ptr(p->fstype, "tmpfs")) {
503 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_SWAP_TARGET, NULL, true, mask);
504 if (r < 0)
505 return r;
506 }
507
508 return 0;
509 }
510
511 static int mount_verify(Mount *m) {
512 _cleanup_free_ char *e = NULL;
513 MountParameters *p;
514 int r;
515
516 assert(m);
517
518 if (UNIT(m)->load_state != UNIT_LOADED)
519 return 0;
520
521 if (!m->from_fragment && !m->from_proc_self_mountinfo && !UNIT(m)->perpetual)
522 return -ENOENT;
523
524 r = unit_name_from_path(m->where, ".mount", &e);
525 if (r < 0)
526 return log_unit_error_errno(UNIT(m), r, "Failed to generate unit name from mount path: %m");
527
528 if (!unit_has_name(UNIT(m), e)) {
529 log_unit_error(UNIT(m), "Where= setting doesn't match unit name. Refusing.");
530 return -EINVAL;
531 }
532
533 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
534 log_unit_error(UNIT(m), "Cannot create mount unit for API file system %s. Refusing.", m->where);
535 return -EINVAL;
536 }
537
538 p = get_mount_parameters_fragment(m);
539 if (p && !p->what) {
540 log_unit_error(UNIT(m), "What= setting is missing. Refusing.");
541 return -EBADMSG;
542 }
543
544 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
545 log_unit_error(UNIT(m), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
546 return -EINVAL;
547 }
548
549 return 0;
550 }
551
552 static int mount_add_extras(Mount *m) {
553 Unit *u = UNIT(m);
554 int r;
555
556 assert(m);
557
558 if (u->fragment_path)
559 m->from_fragment = true;
560
561 if (!m->where) {
562 r = unit_name_to_path(u->id, &m->where);
563 if (r < 0)
564 return r;
565 }
566
567 path_kill_slashes(m->where);
568
569 if (!u->description) {
570 r = unit_set_description(u, m->where);
571 if (r < 0)
572 return r;
573 }
574
575 r = mount_add_device_dependencies(m);
576 if (r < 0)
577 return r;
578
579 r = mount_add_mount_dependencies(m);
580 if (r < 0)
581 return r;
582
583 r = mount_add_quota_dependencies(m);
584 if (r < 0)
585 return r;
586
587 r = unit_patch_contexts(u);
588 if (r < 0)
589 return r;
590
591 r = unit_add_exec_dependencies(u, &m->exec_context);
592 if (r < 0)
593 return r;
594
595 r = unit_set_default_slice(u);
596 if (r < 0)
597 return r;
598
599 r = mount_add_default_dependencies(m);
600 if (r < 0)
601 return r;
602
603 return 0;
604 }
605
606 static int mount_load_root_mount(Unit *u) {
607 assert(u);
608
609 if (!unit_has_name(u, SPECIAL_ROOT_MOUNT))
610 return 0;
611
612 u->perpetual = true;
613 u->default_dependencies = false;
614
615 /* The stdio/kmsg bridge socket is on /, in order to avoid a dep loop, don't use kmsg logging for -.mount */
616 MOUNT(u)->exec_context.std_output = EXEC_OUTPUT_NULL;
617 MOUNT(u)->exec_context.std_input = EXEC_INPUT_NULL;
618
619 if (!u->description)
620 u->description = strdup("Root Mount");
621
622 return 1;
623 }
624
625 static int mount_load(Unit *u) {
626 Mount *m = MOUNT(u);
627 int r;
628
629 assert(u);
630 assert(u->load_state == UNIT_STUB);
631
632 r = mount_load_root_mount(u);
633 if (r < 0)
634 return r;
635
636 if (m->from_proc_self_mountinfo || u->perpetual)
637 r = unit_load_fragment_and_dropin_optional(u);
638 else
639 r = unit_load_fragment_and_dropin(u);
640 if (r < 0)
641 return r;
642
643 /* This is a new unit? Then let's add in some extras */
644 if (u->load_state == UNIT_LOADED) {
645 r = mount_add_extras(m);
646 if (r < 0)
647 return r;
648 }
649
650 return mount_verify(m);
651 }
652
653 static void mount_set_state(Mount *m, MountState state) {
654 MountState old_state;
655 assert(m);
656
657 old_state = m->state;
658 m->state = state;
659
660 if (!MOUNT_STATE_WITH_PROCESS(state)) {
661 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
662 mount_unwatch_control_pid(m);
663 m->control_command = NULL;
664 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
665 }
666
667 if (state != old_state)
668 log_unit_debug(UNIT(m), "Changed %s -> %s", mount_state_to_string(old_state), mount_state_to_string(state));
669
670 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
671 }
672
673 static int mount_coldplug(Unit *u) {
674 Mount *m = MOUNT(u);
675 MountState new_state = MOUNT_DEAD;
676 int r;
677
678 assert(m);
679 assert(m->state == MOUNT_DEAD);
680
681 if (m->deserialized_state != m->state)
682 new_state = m->deserialized_state;
683 else if (m->from_proc_self_mountinfo)
684 new_state = MOUNT_MOUNTED;
685
686 if (new_state == m->state)
687 return 0;
688
689 if (m->control_pid > 0 &&
690 pid_is_unwaited(m->control_pid) &&
691 MOUNT_STATE_WITH_PROCESS(new_state)) {
692
693 r = unit_watch_pid(UNIT(m), m->control_pid);
694 if (r < 0)
695 return r;
696
697 r = mount_arm_timer(m, usec_add(u->state_change_timestamp.monotonic, m->timeout_usec));
698 if (r < 0)
699 return r;
700 }
701
702 if (!IN_SET(new_state, MOUNT_DEAD, MOUNT_FAILED))
703 (void) unit_setup_dynamic_creds(u);
704
705 mount_set_state(m, new_state);
706 return 0;
707 }
708
709 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
710 char buf[FORMAT_TIMESPAN_MAX] = {};
711 Mount *m = MOUNT(u);
712 MountParameters *p;
713
714 assert(m);
715 assert(f);
716
717 p = get_mount_parameters(m);
718
719 fprintf(f,
720 "%sMount State: %s\n"
721 "%sResult: %s\n"
722 "%sWhere: %s\n"
723 "%sWhat: %s\n"
724 "%sFile System Type: %s\n"
725 "%sOptions: %s\n"
726 "%sFrom /proc/self/mountinfo: %s\n"
727 "%sFrom fragment: %s\n"
728 "%sExtrinsic: %s\n"
729 "%sDirectoryMode: %04o\n"
730 "%sSloppyOptions: %s\n"
731 "%sLazyUnmount: %s\n"
732 "%sForceUnmount: %s\n"
733 "%sTimoutSec: %s\n",
734 prefix, mount_state_to_string(m->state),
735 prefix, mount_result_to_string(m->result),
736 prefix, m->where,
737 prefix, p ? strna(p->what) : "n/a",
738 prefix, p ? strna(p->fstype) : "n/a",
739 prefix, p ? strna(p->options) : "n/a",
740 prefix, yes_no(m->from_proc_self_mountinfo),
741 prefix, yes_no(m->from_fragment),
742 prefix, yes_no(mount_is_extrinsic(m)),
743 prefix, m->directory_mode,
744 prefix, yes_no(m->sloppy_options),
745 prefix, yes_no(m->lazy_unmount),
746 prefix, yes_no(m->force_unmount),
747 prefix, format_timespan(buf, sizeof(buf), m->timeout_usec, USEC_PER_SEC));
748
749 if (m->control_pid > 0)
750 fprintf(f,
751 "%sControl PID: "PID_FMT"\n",
752 prefix, m->control_pid);
753
754 exec_context_dump(&m->exec_context, f, prefix);
755 kill_context_dump(&m->kill_context, f, prefix);
756 cgroup_context_dump(&m->cgroup_context, f, prefix);
757 }
758
759 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
760
761 ExecParameters exec_params = {
762 .flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
763 .stdin_fd = -1,
764 .stdout_fd = -1,
765 .stderr_fd = -1,
766 };
767 pid_t pid;
768 int r;
769
770 assert(m);
771 assert(c);
772 assert(_pid);
773
774 r = unit_prepare_exec(UNIT(m));
775 if (r < 0)
776 return r;
777
778 r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
779 if (r < 0)
780 return r;
781
782 manager_set_exec_params(UNIT(m)->manager, &exec_params);
783 unit_set_exec_params(UNIT(m), &exec_params);
784
785 r = exec_spawn(UNIT(m),
786 c,
787 &m->exec_context,
788 &exec_params,
789 m->exec_runtime,
790 &m->dynamic_creds,
791 &pid);
792 if (r < 0)
793 return r;
794
795 r = unit_watch_pid(UNIT(m), pid);
796 if (r < 0)
797 /* FIXME: we need to do something here */
798 return r;
799
800 *_pid = pid;
801
802 return 0;
803 }
804
805 static void mount_enter_dead(Mount *m, MountResult f) {
806 assert(m);
807
808 if (m->result == MOUNT_SUCCESS)
809 m->result = f;
810
811 if (m->result != MOUNT_SUCCESS)
812 log_unit_warning(UNIT(m), "Failed with result '%s'.", mount_result_to_string(m->result));
813
814 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
815
816 exec_runtime_destroy(m->exec_runtime);
817 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
818
819 exec_context_destroy_runtime_directory(&m->exec_context, UNIT(m)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
820
821 unit_unref_uid_gid(UNIT(m), true);
822
823 dynamic_creds_destroy(&m->dynamic_creds);
824 }
825
826 static void mount_enter_mounted(Mount *m, MountResult f) {
827 assert(m);
828
829 if (m->result == MOUNT_SUCCESS)
830 m->result = f;
831
832 mount_set_state(m, MOUNT_MOUNTED);
833 }
834
835 static void mount_enter_dead_or_mounted(Mount *m, MountResult f) {
836 assert(m);
837
838 /* Enter DEAD or MOUNTED state, depending on what the kernel currently says about the mount point. We use this
839 * whenever we executed an operation, so that our internal state reflects what the kernel says again, after all
840 * ultimately we just mirror the kernel's internal state on this. */
841
842 if (m->from_proc_self_mountinfo)
843 mount_enter_mounted(m, f);
844 else
845 mount_enter_dead(m, f);
846 }
847
848 static int state_to_kill_operation(MountState state) {
849 switch (state) {
850
851 case MOUNT_REMOUNTING_SIGTERM:
852 case MOUNT_UNMOUNTING_SIGTERM:
853 return KILL_TERMINATE;
854
855 case MOUNT_REMOUNTING_SIGKILL:
856 case MOUNT_UNMOUNTING_SIGKILL:
857 return KILL_KILL;
858
859 default:
860 return _KILL_OPERATION_INVALID;
861 }
862 }
863
864 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
865 int r;
866
867 assert(m);
868
869 if (m->result == MOUNT_SUCCESS)
870 m->result = f;
871
872 r = unit_kill_context(
873 UNIT(m),
874 &m->kill_context,
875 state_to_kill_operation(state),
876 -1,
877 m->control_pid,
878 false);
879 if (r < 0)
880 goto fail;
881
882 if (r > 0) {
883 r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
884 if (r < 0)
885 goto fail;
886
887 mount_set_state(m, state);
888 } else if (state == MOUNT_REMOUNTING_SIGTERM && m->kill_context.send_sigkill)
889 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
890 else if (IN_SET(state, MOUNT_REMOUNTING_SIGTERM, MOUNT_REMOUNTING_SIGKILL))
891 mount_enter_mounted(m, MOUNT_SUCCESS);
892 else if (state == MOUNT_UNMOUNTING_SIGTERM && m->kill_context.send_sigkill)
893 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
894 else
895 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
896
897 return;
898
899 fail:
900 log_unit_warning_errno(UNIT(m), r, "Failed to kill processes: %m");
901 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
902 }
903
904 static void mount_enter_unmounting(Mount *m) {
905 int r;
906
907 assert(m);
908
909 /* Start counting our attempts */
910 if (!IN_SET(m->state,
911 MOUNT_UNMOUNTING,
912 MOUNT_UNMOUNTING_SIGTERM,
913 MOUNT_UNMOUNTING_SIGKILL))
914 m->n_retry_umount = 0;
915
916 m->control_command_id = MOUNT_EXEC_UNMOUNT;
917 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
918
919 r = exec_command_set(m->control_command, UMOUNT_PATH, m->where, "-c", NULL);
920 if (r >= 0 && m->lazy_unmount)
921 r = exec_command_append(m->control_command, "-l", NULL);
922 if (r >= 0 && m->force_unmount)
923 r = exec_command_append(m->control_command, "-f", NULL);
924 if (r < 0)
925 goto fail;
926
927 mount_unwatch_control_pid(m);
928
929 r = mount_spawn(m, m->control_command, &m->control_pid);
930 if (r < 0)
931 goto fail;
932
933 mount_set_state(m, MOUNT_UNMOUNTING);
934
935 return;
936
937 fail:
938 log_unit_warning_errno(UNIT(m), r, "Failed to run 'umount' task: %m");
939 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
940 }
941
942 static void mount_enter_mounting(Mount *m) {
943 int r;
944 MountParameters *p;
945
946 assert(m);
947
948 r = unit_fail_if_noncanonical(UNIT(m), m->where);
949 if (r < 0)
950 goto fail;
951
952 (void) mkdir_p_label(m->where, m->directory_mode);
953
954 unit_warn_if_dir_nonempty(UNIT(m), m->where);
955
956 unit_warn_leftover_processes(UNIT(m));
957
958 m->control_command_id = MOUNT_EXEC_MOUNT;
959 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
960
961 /* Create the source directory for bind-mounts if needed */
962 p = get_mount_parameters_fragment(m);
963 if (p && mount_is_bind(p))
964 (void) mkdir_p_label(p->what, m->directory_mode);
965
966 if (p) {
967 _cleanup_free_ char *opts = NULL;
968
969 r = fstab_filter_options(p->options, "nofail\0" "noauto\0" "auto\0", NULL, NULL, &opts);
970 if (r < 0)
971 goto fail;
972
973 r = exec_command_set(m->control_command, MOUNT_PATH, p->what, m->where, NULL);
974 if (r >= 0 && m->sloppy_options)
975 r = exec_command_append(m->control_command, "-s", NULL);
976 if (r >= 0 && p->fstype)
977 r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
978 if (r >= 0 && !isempty(opts))
979 r = exec_command_append(m->control_command, "-o", opts, NULL);
980 } else
981 r = -ENOENT;
982 if (r < 0)
983 goto fail;
984
985 mount_unwatch_control_pid(m);
986
987 r = mount_spawn(m, m->control_command, &m->control_pid);
988 if (r < 0)
989 goto fail;
990
991 mount_set_state(m, MOUNT_MOUNTING);
992
993 return;
994
995 fail:
996 log_unit_warning_errno(UNIT(m), r, "Failed to run 'mount' task: %m");
997 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
998 }
999
1000 static void mount_set_reload_result(Mount *m, MountResult result) {
1001 assert(m);
1002
1003 /* Only store the first error we encounter */
1004 if (m->reload_result != MOUNT_SUCCESS)
1005 return;
1006
1007 m->reload_result = result;
1008 }
1009
1010 static void mount_enter_remounting(Mount *m) {
1011 int r;
1012 MountParameters *p;
1013
1014 assert(m);
1015
1016 /* Reset reload result when we are about to start a new remount operation */
1017 m->reload_result = MOUNT_SUCCESS;
1018
1019 m->control_command_id = MOUNT_EXEC_REMOUNT;
1020 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1021
1022 p = get_mount_parameters_fragment(m);
1023 if (p) {
1024 const char *o;
1025
1026 if (p->options)
1027 o = strjoina("remount,", p->options);
1028 else
1029 o = "remount";
1030
1031 r = exec_command_set(m->control_command, MOUNT_PATH,
1032 p->what, m->where,
1033 "-o", o, NULL);
1034 if (r >= 0 && m->sloppy_options)
1035 r = exec_command_append(m->control_command, "-s", NULL);
1036 if (r >= 0 && p->fstype)
1037 r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
1038 } else
1039 r = -ENOENT;
1040 if (r < 0)
1041 goto fail;
1042
1043 mount_unwatch_control_pid(m);
1044
1045 r = mount_spawn(m, m->control_command, &m->control_pid);
1046 if (r < 0)
1047 goto fail;
1048
1049 mount_set_state(m, MOUNT_REMOUNTING);
1050
1051 return;
1052
1053 fail:
1054 log_unit_warning_errno(UNIT(m), r, "Failed to run 'remount' task: %m");
1055 mount_set_reload_result(m, MOUNT_FAILURE_RESOURCES);
1056 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1057 }
1058
1059 static int mount_start(Unit *u) {
1060 Mount *m = MOUNT(u);
1061 int r;
1062
1063 assert(m);
1064
1065 /* We cannot fulfill this request right now, try again later
1066 * please! */
1067 if (IN_SET(m->state,
1068 MOUNT_UNMOUNTING,
1069 MOUNT_UNMOUNTING_SIGTERM,
1070 MOUNT_UNMOUNTING_SIGKILL))
1071 return -EAGAIN;
1072
1073 /* Already on it! */
1074 if (m->state == MOUNT_MOUNTING)
1075 return 0;
1076
1077 assert(IN_SET(m->state, MOUNT_DEAD, MOUNT_FAILED));
1078
1079 r = unit_start_limit_test(u);
1080 if (r < 0) {
1081 mount_enter_dead(m, MOUNT_FAILURE_START_LIMIT_HIT);
1082 return r;
1083 }
1084
1085 r = unit_acquire_invocation_id(u);
1086 if (r < 0)
1087 return r;
1088
1089 m->result = MOUNT_SUCCESS;
1090 m->reload_result = MOUNT_SUCCESS;
1091
1092 u->reset_accounting = true;
1093
1094 mount_enter_mounting(m);
1095 return 1;
1096 }
1097
1098 static int mount_stop(Unit *u) {
1099 Mount *m = MOUNT(u);
1100
1101 assert(m);
1102
1103 switch (m->state) {
1104
1105 case MOUNT_UNMOUNTING:
1106 case MOUNT_UNMOUNTING_SIGKILL:
1107 case MOUNT_UNMOUNTING_SIGTERM:
1108 /* Already on it */
1109 return 0;
1110
1111 case MOUNT_MOUNTING:
1112 case MOUNT_MOUNTING_DONE:
1113 case MOUNT_REMOUNTING:
1114 /* If we are still waiting for /bin/mount, we go directly into kill mode. */
1115 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_SUCCESS);
1116 return 0;
1117
1118 case MOUNT_REMOUNTING_SIGTERM:
1119 /* If we are already waiting for a hung remount, convert this to the matching unmounting state */
1120 mount_set_state(m, MOUNT_UNMOUNTING_SIGTERM);
1121 return 0;
1122
1123 case MOUNT_REMOUNTING_SIGKILL:
1124 /* as above */
1125 mount_set_state(m, MOUNT_UNMOUNTING_SIGKILL);
1126 return 0;
1127
1128 case MOUNT_MOUNTED:
1129 mount_enter_unmounting(m);
1130 return 1;
1131
1132 default:
1133 assert_not_reached("Unexpected state.");
1134 }
1135 }
1136
1137 static int mount_reload(Unit *u) {
1138 Mount *m = MOUNT(u);
1139
1140 assert(m);
1141 assert(m->state == MOUNT_MOUNTED);
1142
1143 mount_enter_remounting(m);
1144
1145 return 1;
1146 }
1147
1148 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1149 Mount *m = MOUNT(u);
1150
1151 assert(m);
1152 assert(f);
1153 assert(fds);
1154
1155 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1156 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1157 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1158
1159 if (m->control_pid > 0)
1160 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1161
1162 if (m->control_command_id >= 0)
1163 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1164
1165 return 0;
1166 }
1167
1168 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1169 Mount *m = MOUNT(u);
1170
1171 assert(u);
1172 assert(key);
1173 assert(value);
1174 assert(fds);
1175
1176 if (streq(key, "state")) {
1177 MountState state;
1178
1179 if ((state = mount_state_from_string(value)) < 0)
1180 log_unit_debug(u, "Failed to parse state value: %s", value);
1181 else
1182 m->deserialized_state = state;
1183 } else if (streq(key, "result")) {
1184 MountResult f;
1185
1186 f = mount_result_from_string(value);
1187 if (f < 0)
1188 log_unit_debug(u, "Failed to parse result value: %s", value);
1189 else if (f != MOUNT_SUCCESS)
1190 m->result = f;
1191
1192 } else if (streq(key, "reload-result")) {
1193 MountResult f;
1194
1195 f = mount_result_from_string(value);
1196 if (f < 0)
1197 log_unit_debug(u, "Failed to parse reload result value: %s", value);
1198 else if (f != MOUNT_SUCCESS)
1199 m->reload_result = f;
1200
1201 } else if (streq(key, "control-pid")) {
1202 pid_t pid;
1203
1204 if (parse_pid(value, &pid) < 0)
1205 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
1206 else
1207 m->control_pid = pid;
1208 } else if (streq(key, "control-command")) {
1209 MountExecCommand id;
1210
1211 id = mount_exec_command_from_string(value);
1212 if (id < 0)
1213 log_unit_debug(u, "Failed to parse exec-command value: %s", value);
1214 else {
1215 m->control_command_id = id;
1216 m->control_command = m->exec_command + id;
1217 }
1218 } else
1219 log_unit_debug(u, "Unknown serialization key: %s", key);
1220
1221 return 0;
1222 }
1223
1224 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1225 assert(u);
1226
1227 return state_translation_table[MOUNT(u)->state];
1228 }
1229
1230 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1231 assert(u);
1232
1233 return mount_state_to_string(MOUNT(u)->state);
1234 }
1235
1236 _pure_ static bool mount_check_gc(Unit *u) {
1237 Mount *m = MOUNT(u);
1238
1239 assert(m);
1240
1241 return m->from_proc_self_mountinfo;
1242 }
1243
1244 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1245 Mount *m = MOUNT(u);
1246 MountResult f;
1247
1248 assert(m);
1249 assert(pid >= 0);
1250
1251 if (pid != m->control_pid)
1252 return;
1253
1254 m->control_pid = 0;
1255
1256 if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
1257 f = MOUNT_SUCCESS;
1258 else if (code == CLD_EXITED)
1259 f = MOUNT_FAILURE_EXIT_CODE;
1260 else if (code == CLD_KILLED)
1261 f = MOUNT_FAILURE_SIGNAL;
1262 else if (code == CLD_DUMPED)
1263 f = MOUNT_FAILURE_CORE_DUMP;
1264 else
1265 assert_not_reached("Unknown code");
1266
1267 if (IN_SET(m->state, MOUNT_REMOUNTING, MOUNT_REMOUNTING_SIGKILL, MOUNT_REMOUNTING_SIGTERM))
1268 mount_set_reload_result(m, f);
1269 else if (m->result == MOUNT_SUCCESS)
1270 m->result = f;
1271
1272 if (m->control_command) {
1273 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1274
1275 m->control_command = NULL;
1276 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1277 }
1278
1279 log_unit_full(u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
1280 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code), status);
1281
1282 /* Note that due to the io event priority logic, we can be sure the new mountinfo is loaded
1283 * before we process the SIGCHLD for the mount command. */
1284
1285 switch (m->state) {
1286
1287 case MOUNT_MOUNTING:
1288 /* Our mount point has not appeared in mountinfo. Something went wrong. */
1289
1290 if (f == MOUNT_SUCCESS) {
1291 /* Either /bin/mount has an unexpected definition of success,
1292 * or someone raced us and we lost. */
1293 log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
1294 f = MOUNT_FAILURE_PROTOCOL;
1295 }
1296 mount_enter_dead(m, f);
1297 break;
1298
1299 case MOUNT_MOUNTING_DONE:
1300 mount_enter_mounted(m, f);
1301 break;
1302
1303 case MOUNT_REMOUNTING:
1304 case MOUNT_REMOUNTING_SIGTERM:
1305 case MOUNT_REMOUNTING_SIGKILL:
1306 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1307 break;
1308
1309 case MOUNT_UNMOUNTING:
1310
1311 if (f == MOUNT_SUCCESS && m->from_proc_self_mountinfo) {
1312
1313 /* Still a mount point? If so, let's try again. Most likely there were multiple mount points
1314 * stacked on top of each other. We might exceed the timeout specified by the user overall,
1315 * but we will stop as soon as any one umount times out. */
1316
1317 if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
1318 log_unit_debug(u, "Mount still present, trying again.");
1319 m->n_retry_umount++;
1320 mount_enter_unmounting(m);
1321 } else {
1322 log_unit_warning(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
1323 mount_enter_mounted(m, f);
1324 }
1325 } else
1326 mount_enter_dead_or_mounted(m, f);
1327
1328 break;
1329
1330 case MOUNT_UNMOUNTING_SIGKILL:
1331 case MOUNT_UNMOUNTING_SIGTERM:
1332 mount_enter_dead_or_mounted(m, f);
1333 break;
1334
1335 default:
1336 assert_not_reached("Uh, control process died at wrong time.");
1337 }
1338
1339 /* Notify clients about changed exit status */
1340 unit_add_to_dbus_queue(u);
1341 }
1342
1343 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1344 Mount *m = MOUNT(userdata);
1345
1346 assert(m);
1347 assert(m->timer_event_source == source);
1348
1349 switch (m->state) {
1350
1351 case MOUNT_MOUNTING:
1352 case MOUNT_MOUNTING_DONE:
1353 log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
1354 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1355 break;
1356
1357 case MOUNT_REMOUNTING:
1358 log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
1359 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1360 mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
1361 break;
1362
1363 case MOUNT_REMOUNTING_SIGTERM:
1364 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1365
1366 if (m->kill_context.send_sigkill) {
1367 log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
1368 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
1369 } else {
1370 log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1371 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1372 }
1373 break;
1374
1375 case MOUNT_REMOUNTING_SIGKILL:
1376 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1377
1378 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1379 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1380 break;
1381
1382 case MOUNT_UNMOUNTING:
1383 log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
1384 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1385 break;
1386
1387 case MOUNT_UNMOUNTING_SIGTERM:
1388 if (m->kill_context.send_sigkill) {
1389 log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
1390 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1391 } else {
1392 log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
1393 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1394 }
1395 break;
1396
1397 case MOUNT_UNMOUNTING_SIGKILL:
1398 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1399 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1400 break;
1401
1402 default:
1403 assert_not_reached("Timeout at wrong time.");
1404 }
1405
1406 return 0;
1407 }
1408
1409 typedef struct {
1410 bool is_mounted;
1411 bool just_mounted;
1412 bool just_changed;
1413 } MountSetupFlags;
1414
1415 static int mount_setup_new_unit(
1416 Unit *u,
1417 const char *what,
1418 const char *where,
1419 const char *options,
1420 const char *fstype,
1421 MountSetupFlags *flags) {
1422
1423 MountParameters *p;
1424
1425 assert(u);
1426 assert(flags);
1427
1428 u->source_path = strdup("/proc/self/mountinfo");
1429 MOUNT(u)->where = strdup(where);
1430 if (!u->source_path || !MOUNT(u)->where)
1431 return -ENOMEM;
1432
1433 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1434 MOUNT(u)->from_proc_self_mountinfo = true;
1435 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1436
1437 p->what = strdup(what);
1438 p->options = strdup(options);
1439 p->fstype = strdup(fstype);
1440 if (!p->what || !p->options || !p->fstype)
1441 return -ENOMEM;
1442
1443 if (!mount_is_extrinsic(MOUNT(u))) {
1444 const char *target;
1445 int r;
1446
1447 target = mount_is_network(p) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1448 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1449 if (r < 0)
1450 return r;
1451
1452 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1453 if (r < 0)
1454 return r;
1455 }
1456
1457 unit_add_to_load_queue(u);
1458 flags->is_mounted = true;
1459 flags->just_mounted = true;
1460 flags->just_changed = true;
1461
1462 return 0;
1463 }
1464
1465 static int mount_setup_existing_unit(
1466 Unit *u,
1467 const char *what,
1468 const char *where,
1469 const char *options,
1470 const char *fstype,
1471 MountSetupFlags *flags) {
1472
1473 MountParameters *p;
1474 bool load_extras = false;
1475 int r1, r2, r3;
1476
1477 assert(u);
1478 assert(flags);
1479
1480 if (!MOUNT(u)->where) {
1481 MOUNT(u)->where = strdup(where);
1482 if (!MOUNT(u)->where)
1483 return -ENOMEM;
1484 }
1485
1486 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1487 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1488
1489 r1 = free_and_strdup(&p->what, what);
1490 r2 = free_and_strdup(&p->options, options);
1491 r3 = free_and_strdup(&p->fstype, fstype);
1492 if (r1 < 0 || r2 < 0 || r3 < 0)
1493 return -ENOMEM;
1494
1495 flags->just_changed = r1 > 0 || r2 > 0 || r3 > 0;
1496 flags->is_mounted = true;
1497 flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
1498
1499 MOUNT(u)->from_proc_self_mountinfo = true;
1500
1501 if (!mount_is_extrinsic(MOUNT(u)) && mount_is_network(p)) {
1502 /* _netdev option may have shown up late, or on a
1503 * remount. Add remote-fs dependencies, even though
1504 * local-fs ones may already be there.
1505 *
1506 * Note: due to a current limitation (we don't track
1507 * in the dependency "Set*" objects who created a
1508 * dependency), we can only add deps, never lose them,
1509 * until the next full daemon-reload. */
1510 unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1511 load_extras = true;
1512 }
1513
1514 if (u->load_state == UNIT_NOT_FOUND) {
1515 u->load_state = UNIT_LOADED;
1516 u->load_error = 0;
1517
1518 /* Load in the extras later on, after we
1519 * finished initialization of the unit */
1520
1521 /* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
1522 load_extras = true;
1523 flags->just_changed = true;
1524 }
1525
1526 if (load_extras)
1527 return mount_add_extras(MOUNT(u));
1528
1529 return 0;
1530 }
1531
1532 static int mount_setup_unit(
1533 Manager *m,
1534 const char *what,
1535 const char *where,
1536 const char *options,
1537 const char *fstype,
1538 bool set_flags) {
1539
1540 _cleanup_free_ char *e = NULL;
1541 MountSetupFlags flags;
1542 Unit *u;
1543 int r;
1544
1545 assert(m);
1546 assert(what);
1547 assert(where);
1548 assert(options);
1549 assert(fstype);
1550
1551 /* Ignore API mount points. They should never be referenced in
1552 * dependencies ever. */
1553 if (mount_point_is_api(where) || mount_point_ignore(where))
1554 return 0;
1555
1556 if (streq(fstype, "autofs"))
1557 return 0;
1558
1559 /* probably some kind of swap, ignore */
1560 if (!is_path(where))
1561 return 0;
1562
1563 r = unit_name_from_path(where, ".mount", &e);
1564 if (r < 0)
1565 return r;
1566
1567 u = manager_get_unit(m, e);
1568 if (!u) {
1569 /* First time we see this mount point meaning that it's
1570 * not been initiated by a mount unit but rather by the
1571 * sysadmin having called mount(8) directly. */
1572 r = unit_new_for_name(m, sizeof(Mount), e, &u);
1573 if (r < 0)
1574 goto fail;
1575
1576 r = mount_setup_new_unit(u, what, where, options, fstype, &flags);
1577 if (r < 0)
1578 unit_free(u);
1579 } else
1580 r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
1581
1582 if (r < 0)
1583 goto fail;
1584
1585 if (set_flags) {
1586 MOUNT(u)->is_mounted = flags.is_mounted;
1587 MOUNT(u)->just_mounted = flags.just_mounted;
1588 MOUNT(u)->just_changed = flags.just_changed;
1589 }
1590
1591 if (flags.just_changed)
1592 unit_add_to_dbus_queue(u);
1593
1594 return 0;
1595 fail:
1596 log_warning_errno(r, "Failed to set up mount unit: %m");
1597 return r;
1598 }
1599
1600 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1601 _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
1602 _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
1603 int r = 0;
1604
1605 assert(m);
1606
1607 t = mnt_new_table();
1608 if (!t)
1609 return log_oom();
1610
1611 i = mnt_new_iter(MNT_ITER_FORWARD);
1612 if (!i)
1613 return log_oom();
1614
1615 r = mnt_table_parse_mtab(t, NULL);
1616 if (r < 0)
1617 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
1618
1619 r = 0;
1620 for (;;) {
1621 const char *device, *path, *options, *fstype;
1622 _cleanup_free_ char *d = NULL, *p = NULL;
1623 struct libmnt_fs *fs;
1624 int k;
1625
1626 k = mnt_table_next_fs(t, i, &fs);
1627 if (k == 1)
1628 break;
1629 if (k < 0)
1630 return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
1631
1632 device = mnt_fs_get_source(fs);
1633 path = mnt_fs_get_target(fs);
1634 options = mnt_fs_get_options(fs);
1635 fstype = mnt_fs_get_fstype(fs);
1636
1637 if (!device || !path)
1638 continue;
1639
1640 if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
1641 return log_oom();
1642
1643 if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
1644 return log_oom();
1645
1646 (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
1647
1648 k = mount_setup_unit(m, d, p, options, fstype, set_flags);
1649 if (r == 0 && k < 0)
1650 r = k;
1651 }
1652
1653 return r;
1654 }
1655
1656 static void mount_shutdown(Manager *m) {
1657 assert(m);
1658
1659 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1660
1661 mnt_unref_monitor(m->mount_monitor);
1662 m->mount_monitor = NULL;
1663 }
1664
1665 static int mount_get_timeout(Unit *u, usec_t *timeout) {
1666 Mount *m = MOUNT(u);
1667 usec_t t;
1668 int r;
1669
1670 if (!m->timer_event_source)
1671 return 0;
1672
1673 r = sd_event_source_get_time(m->timer_event_source, &t);
1674 if (r < 0)
1675 return r;
1676 if (t == USEC_INFINITY)
1677 return 0;
1678
1679 *timeout = t;
1680 return 1;
1681 }
1682
1683 static int synthesize_root_mount(Manager *m) {
1684 Unit *u;
1685 int r;
1686
1687 assert(m);
1688
1689 /* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
1690 * unconditionally synthesize it here and mark it as perpetual. */
1691
1692 u = manager_get_unit(m, SPECIAL_ROOT_MOUNT);
1693 if (!u) {
1694 r = unit_new_for_name(m, sizeof(Mount), SPECIAL_ROOT_MOUNT, &u);
1695 if (r < 0)
1696 return log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
1697 }
1698
1699 u->perpetual = true;
1700 MOUNT(u)->deserialized_state = MOUNT_MOUNTED;
1701
1702 unit_add_to_load_queue(u);
1703 unit_add_to_dbus_queue(u);
1704
1705 return 0;
1706 }
1707
1708 static bool mount_is_mounted(Mount *m) {
1709 assert(m);
1710
1711 return UNIT(m)->perpetual || m->is_mounted;
1712 }
1713
1714 static void mount_enumerate(Manager *m) {
1715 int r;
1716
1717 assert(m);
1718
1719 r = synthesize_root_mount(m);
1720 if (r < 0)
1721 goto fail;
1722
1723 mnt_init_debug(0);
1724
1725 if (!m->mount_monitor) {
1726 int fd;
1727
1728 m->mount_monitor = mnt_new_monitor();
1729 if (!m->mount_monitor) {
1730 log_oom();
1731 goto fail;
1732 }
1733
1734 r = mnt_monitor_enable_kernel(m->mount_monitor, 1);
1735 if (r < 0) {
1736 log_error_errno(r, "Failed to enable watching of kernel mount events: %m");
1737 goto fail;
1738 }
1739
1740 r = mnt_monitor_enable_userspace(m->mount_monitor, 1, NULL);
1741 if (r < 0) {
1742 log_error_errno(r, "Failed to enable watching of userspace mount events: %m");
1743 goto fail;
1744 }
1745
1746 /* mnt_unref_monitor() will close the fd */
1747 fd = r = mnt_monitor_get_fd(m->mount_monitor);
1748 if (r < 0) {
1749 log_error_errno(r, "Failed to acquire watch file descriptor: %m");
1750 goto fail;
1751 }
1752
1753 r = sd_event_add_io(m->event, &m->mount_event_source, fd, EPOLLIN, mount_dispatch_io, m);
1754 if (r < 0) {
1755 log_error_errno(r, "Failed to watch mount file descriptor: %m");
1756 goto fail;
1757 }
1758
1759 r = sd_event_source_set_priority(m->mount_event_source, SD_EVENT_PRIORITY_NORMAL-10);
1760 if (r < 0) {
1761 log_error_errno(r, "Failed to adjust mount watch priority: %m");
1762 goto fail;
1763 }
1764
1765 (void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
1766 }
1767
1768 r = mount_load_proc_self_mountinfo(m, false);
1769 if (r < 0)
1770 goto fail;
1771
1772 return;
1773
1774 fail:
1775 mount_shutdown(m);
1776 }
1777
1778 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1779 _cleanup_set_free_ Set *around = NULL, *gone = NULL;
1780 Manager *m = userdata;
1781 const char *what;
1782 Iterator i;
1783 Unit *u;
1784 int r;
1785
1786 assert(m);
1787 assert(revents & EPOLLIN);
1788
1789 if (fd == mnt_monitor_get_fd(m->mount_monitor)) {
1790 bool rescan = false;
1791
1792 /* Drain all events and verify that the event is valid.
1793 *
1794 * Note that libmount also monitors /run/mount mkdir if the
1795 * directory does not exist yet. The mkdir may generate event
1796 * which is irrelevant for us.
1797 *
1798 * error: r < 0; valid: r == 0, false positive: rc == 1 */
1799 do {
1800 r = mnt_monitor_next_change(m->mount_monitor, NULL, NULL);
1801 if (r == 0)
1802 rescan = true;
1803 else if (r < 0)
1804 return log_error_errno(r, "Failed to drain libmount events");
1805 } while (r == 0);
1806
1807 log_debug("libmount event [rescan: %s]", yes_no(rescan));
1808 if (!rescan)
1809 return 0;
1810 }
1811
1812 r = mount_load_proc_self_mountinfo(m, true);
1813 if (r < 0) {
1814 /* Reset flags, just in case, for later calls */
1815 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1816 Mount *mount = MOUNT(u);
1817
1818 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1819 }
1820
1821 return 0;
1822 }
1823
1824 manager_dispatch_load_queue(m);
1825
1826 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1827 Mount *mount = MOUNT(u);
1828
1829 if (!mount_is_mounted(mount)) {
1830
1831 /* A mount point is not around right now. It
1832 * might be gone, or might never have
1833 * existed. */
1834
1835 if (mount->from_proc_self_mountinfo &&
1836 mount->parameters_proc_self_mountinfo.what) {
1837
1838 /* Remember that this device might just have disappeared */
1839 if (set_ensure_allocated(&gone, &string_hash_ops) < 0 ||
1840 set_put(gone, mount->parameters_proc_self_mountinfo.what) < 0)
1841 log_oom(); /* we don't care too much about OOM here... */
1842 }
1843
1844 mount->from_proc_self_mountinfo = false;
1845
1846 switch (mount->state) {
1847
1848 case MOUNT_MOUNTED:
1849 /* This has just been unmounted by
1850 * somebody else, follow the state
1851 * change. */
1852 mount->result = MOUNT_SUCCESS; /* make sure we forget any earlier umount failures */
1853 mount_enter_dead(mount, MOUNT_SUCCESS);
1854 break;
1855
1856 default:
1857 break;
1858 }
1859
1860 } else if (mount->just_mounted || mount->just_changed) {
1861
1862 /* A mount point was added or changed */
1863
1864 switch (mount->state) {
1865
1866 case MOUNT_DEAD:
1867 case MOUNT_FAILED:
1868
1869 /* This has just been mounted by somebody else, follow the state change, but let's
1870 * generate a new invocation ID for this implicitly and automatically. */
1871 (void) unit_acquire_invocation_id(UNIT(mount));
1872 mount_enter_mounted(mount, MOUNT_SUCCESS);
1873 break;
1874
1875 case MOUNT_MOUNTING:
1876 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1877 break;
1878
1879 default:
1880 /* Nothing really changed, but let's
1881 * issue an notification call
1882 * nonetheless, in case somebody is
1883 * waiting for this. (e.g. file system
1884 * ro/rw remounts.) */
1885 mount_set_state(mount, mount->state);
1886 break;
1887 }
1888 }
1889
1890 if (mount_is_mounted(mount) &&
1891 mount->from_proc_self_mountinfo &&
1892 mount->parameters_proc_self_mountinfo.what) {
1893
1894 if (set_ensure_allocated(&around, &string_hash_ops) < 0 ||
1895 set_put(around, mount->parameters_proc_self_mountinfo.what) < 0)
1896 log_oom();
1897 }
1898
1899 /* Reset the flags for later calls */
1900 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1901 }
1902
1903 SET_FOREACH(what, gone, i) {
1904 if (set_contains(around, what))
1905 continue;
1906
1907 /* Let the device units know that the device is no longer mounted */
1908 (void) device_found_node(m, what, false, DEVICE_FOUND_MOUNT, true);
1909 }
1910
1911 return 0;
1912 }
1913
1914 static void mount_reset_failed(Unit *u) {
1915 Mount *m = MOUNT(u);
1916
1917 assert(m);
1918
1919 if (m->state == MOUNT_FAILED)
1920 mount_set_state(m, MOUNT_DEAD);
1921
1922 m->result = MOUNT_SUCCESS;
1923 m->reload_result = MOUNT_SUCCESS;
1924 }
1925
1926 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1927 Mount *m = MOUNT(u);
1928
1929 assert(m);
1930
1931 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1932 }
1933
1934 static int mount_control_pid(Unit *u) {
1935 Mount *m = MOUNT(u);
1936
1937 assert(m);
1938
1939 return m->control_pid;
1940 }
1941
1942 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1943 [MOUNT_EXEC_MOUNT] = "ExecMount",
1944 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1945 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1946 };
1947
1948 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1949
1950 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1951 [MOUNT_SUCCESS] = "success",
1952 [MOUNT_FAILURE_RESOURCES] = "resources",
1953 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1954 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1955 [MOUNT_FAILURE_SIGNAL] = "signal",
1956 [MOUNT_FAILURE_CORE_DUMP] = "core-dump",
1957 [MOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
1958 [MOUNT_FAILURE_PROTOCOL] = "protocol",
1959 };
1960
1961 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1962
1963 const UnitVTable mount_vtable = {
1964 .object_size = sizeof(Mount),
1965 .exec_context_offset = offsetof(Mount, exec_context),
1966 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1967 .kill_context_offset = offsetof(Mount, kill_context),
1968 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1969 .dynamic_creds_offset = offsetof(Mount, dynamic_creds),
1970
1971 .sections =
1972 "Unit\0"
1973 "Mount\0"
1974 "Install\0",
1975 .private_section = "Mount",
1976
1977 .init = mount_init,
1978 .load = mount_load,
1979 .done = mount_done,
1980
1981 .coldplug = mount_coldplug,
1982
1983 .dump = mount_dump,
1984
1985 .start = mount_start,
1986 .stop = mount_stop,
1987 .reload = mount_reload,
1988
1989 .kill = mount_kill,
1990
1991 .serialize = mount_serialize,
1992 .deserialize_item = mount_deserialize_item,
1993
1994 .active_state = mount_active_state,
1995 .sub_state_to_string = mount_sub_state_to_string,
1996
1997 .check_gc = mount_check_gc,
1998
1999 .sigchld_event = mount_sigchld_event,
2000
2001 .reset_failed = mount_reset_failed,
2002
2003 .control_pid = mount_control_pid,
2004
2005 .bus_vtable = bus_mount_vtable,
2006 .bus_set_property = bus_mount_set_property,
2007 .bus_commit_properties = bus_mount_commit_properties,
2008
2009 .get_timeout = mount_get_timeout,
2010
2011 .can_transient = true,
2012
2013 .enumerate = mount_enumerate,
2014 .shutdown = mount_shutdown,
2015
2016 .status_message_formats = {
2017 .starting_stopping = {
2018 [0] = "Mounting %s...",
2019 [1] = "Unmounting %s...",
2020 },
2021 .finished_start_job = {
2022 [JOB_DONE] = "Mounted %s.",
2023 [JOB_FAILED] = "Failed to mount %s.",
2024 [JOB_TIMEOUT] = "Timed out mounting %s.",
2025 },
2026 .finished_stop_job = {
2027 [JOB_DONE] = "Unmounted %s.",
2028 [JOB_FAILED] = "Failed unmounting %s.",
2029 [JOB_TIMEOUT] = "Timed out unmounting %s.",
2030 },
2031 },
2032 };
Unnamed repository; edit this file 'description' to name the repository.