]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/mount.c
pid1: rename unit_check_gc to unit_may_gc
[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, false);
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 (void) unit_setup_exec_runtime(u);
705 }
706
707 mount_set_state(m, new_state);
708 return 0;
709 }
710
711 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
712 char buf[FORMAT_TIMESPAN_MAX];
713 Mount *m = MOUNT(u);
714 MountParameters *p;
715
716 assert(m);
717 assert(f);
718
719 p = get_mount_parameters(m);
720
721 fprintf(f,
722 "%sMount State: %s\n"
723 "%sResult: %s\n"
724 "%sWhere: %s\n"
725 "%sWhat: %s\n"
726 "%sFile System Type: %s\n"
727 "%sOptions: %s\n"
728 "%sFrom /proc/self/mountinfo: %s\n"
729 "%sFrom fragment: %s\n"
730 "%sExtrinsic: %s\n"
731 "%sDirectoryMode: %04o\n"
732 "%sSloppyOptions: %s\n"
733 "%sLazyUnmount: %s\n"
734 "%sForceUnmount: %s\n"
735 "%sTimoutSec: %s\n",
736 prefix, mount_state_to_string(m->state),
737 prefix, mount_result_to_string(m->result),
738 prefix, m->where,
739 prefix, p ? strna(p->what) : "n/a",
740 prefix, p ? strna(p->fstype) : "n/a",
741 prefix, p ? strna(p->options) : "n/a",
742 prefix, yes_no(m->from_proc_self_mountinfo),
743 prefix, yes_no(m->from_fragment),
744 prefix, yes_no(mount_is_extrinsic(m)),
745 prefix, m->directory_mode,
746 prefix, yes_no(m->sloppy_options),
747 prefix, yes_no(m->lazy_unmount),
748 prefix, yes_no(m->force_unmount),
749 prefix, format_timespan(buf, sizeof(buf), m->timeout_usec, USEC_PER_SEC));
750
751 if (m->control_pid > 0)
752 fprintf(f,
753 "%sControl PID: "PID_FMT"\n",
754 prefix, m->control_pid);
755
756 exec_context_dump(&m->exec_context, f, prefix);
757 kill_context_dump(&m->kill_context, f, prefix);
758 cgroup_context_dump(&m->cgroup_context, f, prefix);
759 }
760
761 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
762
763 ExecParameters exec_params = {
764 .flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
765 .stdin_fd = -1,
766 .stdout_fd = -1,
767 .stderr_fd = -1,
768 };
769 pid_t pid;
770 int r;
771
772 assert(m);
773 assert(c);
774 assert(_pid);
775
776 r = unit_prepare_exec(UNIT(m));
777 if (r < 0)
778 return r;
779
780 r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
781 if (r < 0)
782 return r;
783
784 manager_set_exec_params(UNIT(m)->manager, &exec_params);
785 unit_set_exec_params(UNIT(m), &exec_params);
786
787 r = exec_spawn(UNIT(m),
788 c,
789 &m->exec_context,
790 &exec_params,
791 m->exec_runtime,
792 &m->dynamic_creds,
793 &pid);
794 if (r < 0)
795 return r;
796
797 r = unit_watch_pid(UNIT(m), pid);
798 if (r < 0)
799 /* FIXME: we need to do something here */
800 return r;
801
802 *_pid = pid;
803
804 return 0;
805 }
806
807 static void mount_enter_dead(Mount *m, MountResult f) {
808 assert(m);
809
810 if (m->result == MOUNT_SUCCESS)
811 m->result = f;
812
813 if (m->result != MOUNT_SUCCESS)
814 log_unit_warning(UNIT(m), "Failed with result '%s'.", mount_result_to_string(m->result));
815
816 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
817
818 m->exec_runtime = exec_runtime_unref(m->exec_runtime, true);
819
820 exec_context_destroy_runtime_directory(&m->exec_context, UNIT(m)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
821
822 unit_unref_uid_gid(UNIT(m), true);
823
824 dynamic_creds_destroy(&m->dynamic_creds);
825 }
826
827 static void mount_enter_mounted(Mount *m, MountResult f) {
828 assert(m);
829
830 if (m->result == MOUNT_SUCCESS)
831 m->result = f;
832
833 mount_set_state(m, MOUNT_MOUNTED);
834 }
835
836 static void mount_enter_dead_or_mounted(Mount *m, MountResult f) {
837 assert(m);
838
839 /* Enter DEAD or MOUNTED state, depending on what the kernel currently says about the mount point. We use this
840 * whenever we executed an operation, so that our internal state reflects what the kernel says again, after all
841 * ultimately we just mirror the kernel's internal state on this. */
842
843 if (m->from_proc_self_mountinfo)
844 mount_enter_mounted(m, f);
845 else
846 mount_enter_dead(m, f);
847 }
848
849 static int state_to_kill_operation(MountState state) {
850 switch (state) {
851
852 case MOUNT_REMOUNTING_SIGTERM:
853 case MOUNT_UNMOUNTING_SIGTERM:
854 return KILL_TERMINATE;
855
856 case MOUNT_REMOUNTING_SIGKILL:
857 case MOUNT_UNMOUNTING_SIGKILL:
858 return KILL_KILL;
859
860 default:
861 return _KILL_OPERATION_INVALID;
862 }
863 }
864
865 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
866 int r;
867
868 assert(m);
869
870 if (m->result == MOUNT_SUCCESS)
871 m->result = f;
872
873 r = unit_kill_context(
874 UNIT(m),
875 &m->kill_context,
876 state_to_kill_operation(state),
877 -1,
878 m->control_pid,
879 false);
880 if (r < 0)
881 goto fail;
882
883 if (r > 0) {
884 r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
885 if (r < 0)
886 goto fail;
887
888 mount_set_state(m, state);
889 } else if (state == MOUNT_REMOUNTING_SIGTERM && m->kill_context.send_sigkill)
890 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
891 else if (IN_SET(state, MOUNT_REMOUNTING_SIGTERM, MOUNT_REMOUNTING_SIGKILL))
892 mount_enter_mounted(m, MOUNT_SUCCESS);
893 else if (state == MOUNT_UNMOUNTING_SIGTERM && m->kill_context.send_sigkill)
894 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
895 else
896 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
897
898 return;
899
900 fail:
901 log_unit_warning_errno(UNIT(m), r, "Failed to kill processes: %m");
902 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
903 }
904
905 static void mount_enter_unmounting(Mount *m) {
906 int r;
907
908 assert(m);
909
910 /* Start counting our attempts */
911 if (!IN_SET(m->state,
912 MOUNT_UNMOUNTING,
913 MOUNT_UNMOUNTING_SIGTERM,
914 MOUNT_UNMOUNTING_SIGKILL))
915 m->n_retry_umount = 0;
916
917 m->control_command_id = MOUNT_EXEC_UNMOUNT;
918 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
919
920 r = exec_command_set(m->control_command, UMOUNT_PATH, m->where, "-c", NULL);
921 if (r >= 0 && m->lazy_unmount)
922 r = exec_command_append(m->control_command, "-l", NULL);
923 if (r >= 0 && m->force_unmount)
924 r = exec_command_append(m->control_command, "-f", NULL);
925 if (r < 0)
926 goto fail;
927
928 mount_unwatch_control_pid(m);
929
930 r = mount_spawn(m, m->control_command, &m->control_pid);
931 if (r < 0)
932 goto fail;
933
934 mount_set_state(m, MOUNT_UNMOUNTING);
935
936 return;
937
938 fail:
939 log_unit_warning_errno(UNIT(m), r, "Failed to run 'umount' task: %m");
940 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
941 }
942
943 static void mount_enter_mounting(Mount *m) {
944 int r;
945 MountParameters *p;
946
947 assert(m);
948
949 r = unit_fail_if_noncanonical(UNIT(m), m->where);
950 if (r < 0)
951 goto fail;
952
953 (void) mkdir_p_label(m->where, m->directory_mode);
954
955 unit_warn_if_dir_nonempty(UNIT(m), m->where);
956
957 unit_warn_leftover_processes(UNIT(m));
958
959 m->control_command_id = MOUNT_EXEC_MOUNT;
960 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
961
962 /* Create the source directory for bind-mounts if needed */
963 p = get_mount_parameters_fragment(m);
964 if (p && mount_is_bind(p))
965 (void) mkdir_p_label(p->what, m->directory_mode);
966
967 if (p) {
968 _cleanup_free_ char *opts = NULL;
969
970 r = fstab_filter_options(p->options, "nofail\0" "noauto\0" "auto\0", NULL, NULL, &opts);
971 if (r < 0)
972 goto fail;
973
974 r = exec_command_set(m->control_command, MOUNT_PATH, p->what, m->where, NULL);
975 if (r >= 0 && m->sloppy_options)
976 r = exec_command_append(m->control_command, "-s", NULL);
977 if (r >= 0 && p->fstype)
978 r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
979 if (r >= 0 && !isempty(opts))
980 r = exec_command_append(m->control_command, "-o", opts, NULL);
981 } else
982 r = -ENOENT;
983 if (r < 0)
984 goto fail;
985
986 mount_unwatch_control_pid(m);
987
988 r = mount_spawn(m, m->control_command, &m->control_pid);
989 if (r < 0)
990 goto fail;
991
992 mount_set_state(m, MOUNT_MOUNTING);
993
994 return;
995
996 fail:
997 log_unit_warning_errno(UNIT(m), r, "Failed to run 'mount' task: %m");
998 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
999 }
1000
1001 static void mount_set_reload_result(Mount *m, MountResult result) {
1002 assert(m);
1003
1004 /* Only store the first error we encounter */
1005 if (m->reload_result != MOUNT_SUCCESS)
1006 return;
1007
1008 m->reload_result = result;
1009 }
1010
1011 static void mount_enter_remounting(Mount *m) {
1012 int r;
1013 MountParameters *p;
1014
1015 assert(m);
1016
1017 /* Reset reload result when we are about to start a new remount operation */
1018 m->reload_result = MOUNT_SUCCESS;
1019
1020 m->control_command_id = MOUNT_EXEC_REMOUNT;
1021 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1022
1023 p = get_mount_parameters_fragment(m);
1024 if (p) {
1025 const char *o;
1026
1027 if (p->options)
1028 o = strjoina("remount,", p->options);
1029 else
1030 o = "remount";
1031
1032 r = exec_command_set(m->control_command, MOUNT_PATH,
1033 p->what, m->where,
1034 "-o", o, NULL);
1035 if (r >= 0 && m->sloppy_options)
1036 r = exec_command_append(m->control_command, "-s", NULL);
1037 if (r >= 0 && p->fstype)
1038 r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
1039 } else
1040 r = -ENOENT;
1041 if (r < 0)
1042 goto fail;
1043
1044 mount_unwatch_control_pid(m);
1045
1046 r = mount_spawn(m, m->control_command, &m->control_pid);
1047 if (r < 0)
1048 goto fail;
1049
1050 mount_set_state(m, MOUNT_REMOUNTING);
1051
1052 return;
1053
1054 fail:
1055 log_unit_warning_errno(UNIT(m), r, "Failed to run 'remount' task: %m");
1056 mount_set_reload_result(m, MOUNT_FAILURE_RESOURCES);
1057 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1058 }
1059
1060 static int mount_start(Unit *u) {
1061 Mount *m = MOUNT(u);
1062 int r;
1063
1064 assert(m);
1065
1066 /* We cannot fulfill this request right now, try again later
1067 * please! */
1068 if (IN_SET(m->state,
1069 MOUNT_UNMOUNTING,
1070 MOUNT_UNMOUNTING_SIGTERM,
1071 MOUNT_UNMOUNTING_SIGKILL))
1072 return -EAGAIN;
1073
1074 /* Already on it! */
1075 if (m->state == MOUNT_MOUNTING)
1076 return 0;
1077
1078 assert(IN_SET(m->state, MOUNT_DEAD, MOUNT_FAILED));
1079
1080 r = unit_start_limit_test(u);
1081 if (r < 0) {
1082 mount_enter_dead(m, MOUNT_FAILURE_START_LIMIT_HIT);
1083 return r;
1084 }
1085
1086 r = unit_acquire_invocation_id(u);
1087 if (r < 0)
1088 return r;
1089
1090 m->result = MOUNT_SUCCESS;
1091 m->reload_result = MOUNT_SUCCESS;
1092
1093 u->reset_accounting = true;
1094
1095 mount_enter_mounting(m);
1096 return 1;
1097 }
1098
1099 static int mount_stop(Unit *u) {
1100 Mount *m = MOUNT(u);
1101
1102 assert(m);
1103
1104 switch (m->state) {
1105
1106 case MOUNT_UNMOUNTING:
1107 case MOUNT_UNMOUNTING_SIGKILL:
1108 case MOUNT_UNMOUNTING_SIGTERM:
1109 /* Already on it */
1110 return 0;
1111
1112 case MOUNT_MOUNTING:
1113 case MOUNT_MOUNTING_DONE:
1114 case MOUNT_REMOUNTING:
1115 /* If we are still waiting for /bin/mount, we go directly into kill mode. */
1116 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_SUCCESS);
1117 return 0;
1118
1119 case MOUNT_REMOUNTING_SIGTERM:
1120 /* If we are already waiting for a hung remount, convert this to the matching unmounting state */
1121 mount_set_state(m, MOUNT_UNMOUNTING_SIGTERM);
1122 return 0;
1123
1124 case MOUNT_REMOUNTING_SIGKILL:
1125 /* as above */
1126 mount_set_state(m, MOUNT_UNMOUNTING_SIGKILL);
1127 return 0;
1128
1129 case MOUNT_MOUNTED:
1130 mount_enter_unmounting(m);
1131 return 1;
1132
1133 default:
1134 assert_not_reached("Unexpected state.");
1135 }
1136 }
1137
1138 static int mount_reload(Unit *u) {
1139 Mount *m = MOUNT(u);
1140
1141 assert(m);
1142 assert(m->state == MOUNT_MOUNTED);
1143
1144 mount_enter_remounting(m);
1145
1146 return 1;
1147 }
1148
1149 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1150 Mount *m = MOUNT(u);
1151
1152 assert(m);
1153 assert(f);
1154 assert(fds);
1155
1156 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1157 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1158 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1159
1160 if (m->control_pid > 0)
1161 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1162
1163 if (m->control_command_id >= 0)
1164 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1165
1166 return 0;
1167 }
1168
1169 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1170 Mount *m = MOUNT(u);
1171
1172 assert(u);
1173 assert(key);
1174 assert(value);
1175 assert(fds);
1176
1177 if (streq(key, "state")) {
1178 MountState state;
1179
1180 if ((state = mount_state_from_string(value)) < 0)
1181 log_unit_debug(u, "Failed to parse state value: %s", value);
1182 else
1183 m->deserialized_state = state;
1184 } else if (streq(key, "result")) {
1185 MountResult f;
1186
1187 f = mount_result_from_string(value);
1188 if (f < 0)
1189 log_unit_debug(u, "Failed to parse result value: %s", value);
1190 else if (f != MOUNT_SUCCESS)
1191 m->result = f;
1192
1193 } else if (streq(key, "reload-result")) {
1194 MountResult f;
1195
1196 f = mount_result_from_string(value);
1197 if (f < 0)
1198 log_unit_debug(u, "Failed to parse reload result value: %s", value);
1199 else if (f != MOUNT_SUCCESS)
1200 m->reload_result = f;
1201
1202 } else if (streq(key, "control-pid")) {
1203 pid_t pid;
1204
1205 if (parse_pid(value, &pid) < 0)
1206 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
1207 else
1208 m->control_pid = pid;
1209 } else if (streq(key, "control-command")) {
1210 MountExecCommand id;
1211
1212 id = mount_exec_command_from_string(value);
1213 if (id < 0)
1214 log_unit_debug(u, "Failed to parse exec-command value: %s", value);
1215 else {
1216 m->control_command_id = id;
1217 m->control_command = m->exec_command + id;
1218 }
1219 } else
1220 log_unit_debug(u, "Unknown serialization key: %s", key);
1221
1222 return 0;
1223 }
1224
1225 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1226 assert(u);
1227
1228 return state_translation_table[MOUNT(u)->state];
1229 }
1230
1231 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1232 assert(u);
1233
1234 return mount_state_to_string(MOUNT(u)->state);
1235 }
1236
1237 _pure_ static bool mount_may_gc(Unit *u) {
1238 Mount *m = MOUNT(u);
1239
1240 assert(m);
1241
1242 if (m->from_proc_self_mountinfo)
1243 return false;
1244
1245 return true;
1246 }
1247
1248 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1249 Mount *m = MOUNT(u);
1250 MountResult f;
1251
1252 assert(m);
1253 assert(pid >= 0);
1254
1255 if (pid != m->control_pid)
1256 return;
1257
1258 m->control_pid = 0;
1259
1260 if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
1261 f = MOUNT_SUCCESS;
1262 else if (code == CLD_EXITED)
1263 f = MOUNT_FAILURE_EXIT_CODE;
1264 else if (code == CLD_KILLED)
1265 f = MOUNT_FAILURE_SIGNAL;
1266 else if (code == CLD_DUMPED)
1267 f = MOUNT_FAILURE_CORE_DUMP;
1268 else
1269 assert_not_reached("Unknown code");
1270
1271 if (IN_SET(m->state, MOUNT_REMOUNTING, MOUNT_REMOUNTING_SIGKILL, MOUNT_REMOUNTING_SIGTERM))
1272 mount_set_reload_result(m, f);
1273 else if (m->result == MOUNT_SUCCESS)
1274 m->result = f;
1275
1276 if (m->control_command) {
1277 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1278
1279 m->control_command = NULL;
1280 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1281 }
1282
1283 log_unit_full(u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
1284 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code), status);
1285
1286 /* Note that due to the io event priority logic, we can be sure the new mountinfo is loaded
1287 * before we process the SIGCHLD for the mount command. */
1288
1289 switch (m->state) {
1290
1291 case MOUNT_MOUNTING:
1292 /* Our mount point has not appeared in mountinfo. Something went wrong. */
1293
1294 if (f == MOUNT_SUCCESS) {
1295 /* Either /bin/mount has an unexpected definition of success,
1296 * or someone raced us and we lost. */
1297 log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
1298 f = MOUNT_FAILURE_PROTOCOL;
1299 }
1300 mount_enter_dead(m, f);
1301 break;
1302
1303 case MOUNT_MOUNTING_DONE:
1304 mount_enter_mounted(m, f);
1305 break;
1306
1307 case MOUNT_REMOUNTING:
1308 case MOUNT_REMOUNTING_SIGTERM:
1309 case MOUNT_REMOUNTING_SIGKILL:
1310 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1311 break;
1312
1313 case MOUNT_UNMOUNTING:
1314
1315 if (f == MOUNT_SUCCESS && m->from_proc_self_mountinfo) {
1316
1317 /* Still a mount point? If so, let's try again. Most likely there were multiple mount points
1318 * stacked on top of each other. We might exceed the timeout specified by the user overall,
1319 * but we will stop as soon as any one umount times out. */
1320
1321 if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
1322 log_unit_debug(u, "Mount still present, trying again.");
1323 m->n_retry_umount++;
1324 mount_enter_unmounting(m);
1325 } else {
1326 log_unit_warning(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
1327 mount_enter_mounted(m, f);
1328 }
1329 } else
1330 mount_enter_dead_or_mounted(m, f);
1331
1332 break;
1333
1334 case MOUNT_UNMOUNTING_SIGKILL:
1335 case MOUNT_UNMOUNTING_SIGTERM:
1336 mount_enter_dead_or_mounted(m, f);
1337 break;
1338
1339 default:
1340 assert_not_reached("Uh, control process died at wrong time.");
1341 }
1342
1343 /* Notify clients about changed exit status */
1344 unit_add_to_dbus_queue(u);
1345 }
1346
1347 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1348 Mount *m = MOUNT(userdata);
1349
1350 assert(m);
1351 assert(m->timer_event_source == source);
1352
1353 switch (m->state) {
1354
1355 case MOUNT_MOUNTING:
1356 case MOUNT_MOUNTING_DONE:
1357 log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
1358 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1359 break;
1360
1361 case MOUNT_REMOUNTING:
1362 log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
1363 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1364 mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
1365 break;
1366
1367 case MOUNT_REMOUNTING_SIGTERM:
1368 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1369
1370 if (m->kill_context.send_sigkill) {
1371 log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
1372 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
1373 } else {
1374 log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1375 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1376 }
1377 break;
1378
1379 case MOUNT_REMOUNTING_SIGKILL:
1380 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1381
1382 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1383 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1384 break;
1385
1386 case MOUNT_UNMOUNTING:
1387 log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
1388 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1389 break;
1390
1391 case MOUNT_UNMOUNTING_SIGTERM:
1392 if (m->kill_context.send_sigkill) {
1393 log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
1394 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1395 } else {
1396 log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
1397 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1398 }
1399 break;
1400
1401 case MOUNT_UNMOUNTING_SIGKILL:
1402 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1403 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1404 break;
1405
1406 default:
1407 assert_not_reached("Timeout at wrong time.");
1408 }
1409
1410 return 0;
1411 }
1412
1413 typedef struct {
1414 bool is_mounted;
1415 bool just_mounted;
1416 bool just_changed;
1417 } MountSetupFlags;
1418
1419 static int mount_setup_new_unit(
1420 Unit *u,
1421 const char *what,
1422 const char *where,
1423 const char *options,
1424 const char *fstype,
1425 MountSetupFlags *flags) {
1426
1427 MountParameters *p;
1428
1429 assert(u);
1430 assert(flags);
1431
1432 u->source_path = strdup("/proc/self/mountinfo");
1433 MOUNT(u)->where = strdup(where);
1434 if (!u->source_path || !MOUNT(u)->where)
1435 return -ENOMEM;
1436
1437 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1438 MOUNT(u)->from_proc_self_mountinfo = true;
1439 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1440
1441 p->what = strdup(what);
1442 p->options = strdup(options);
1443 p->fstype = strdup(fstype);
1444 if (!p->what || !p->options || !p->fstype)
1445 return -ENOMEM;
1446
1447 if (!mount_is_extrinsic(MOUNT(u))) {
1448 const char *target;
1449 int r;
1450
1451 target = mount_is_network(p) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1452 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1453 if (r < 0)
1454 return r;
1455
1456 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1457 if (r < 0)
1458 return r;
1459 }
1460
1461 unit_add_to_load_queue(u);
1462 flags->is_mounted = true;
1463 flags->just_mounted = true;
1464 flags->just_changed = true;
1465
1466 return 0;
1467 }
1468
1469 static int mount_setup_existing_unit(
1470 Unit *u,
1471 const char *what,
1472 const char *where,
1473 const char *options,
1474 const char *fstype,
1475 MountSetupFlags *flags) {
1476
1477 MountParameters *p;
1478 bool load_extras = false;
1479 int r1, r2, r3;
1480
1481 assert(u);
1482 assert(flags);
1483
1484 if (!MOUNT(u)->where) {
1485 MOUNT(u)->where = strdup(where);
1486 if (!MOUNT(u)->where)
1487 return -ENOMEM;
1488 }
1489
1490 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1491 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1492
1493 r1 = free_and_strdup(&p->what, what);
1494 r2 = free_and_strdup(&p->options, options);
1495 r3 = free_and_strdup(&p->fstype, fstype);
1496 if (r1 < 0 || r2 < 0 || r3 < 0)
1497 return -ENOMEM;
1498
1499 flags->just_changed = r1 > 0 || r2 > 0 || r3 > 0;
1500 flags->is_mounted = true;
1501 flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
1502
1503 MOUNT(u)->from_proc_self_mountinfo = true;
1504
1505 if (!mount_is_extrinsic(MOUNT(u)) && mount_is_network(p)) {
1506 /* _netdev option may have shown up late, or on a
1507 * remount. Add remote-fs dependencies, even though
1508 * local-fs ones may already be there.
1509 *
1510 * Note: due to a current limitation (we don't track
1511 * in the dependency "Set*" objects who created a
1512 * dependency), we can only add deps, never lose them,
1513 * until the next full daemon-reload. */
1514 unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1515 load_extras = true;
1516 }
1517
1518 if (u->load_state == UNIT_NOT_FOUND) {
1519 u->load_state = UNIT_LOADED;
1520 u->load_error = 0;
1521
1522 /* Load in the extras later on, after we
1523 * finished initialization of the unit */
1524
1525 /* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
1526 load_extras = true;
1527 flags->just_changed = true;
1528 }
1529
1530 if (load_extras)
1531 return mount_add_extras(MOUNT(u));
1532
1533 return 0;
1534 }
1535
1536 static int mount_setup_unit(
1537 Manager *m,
1538 const char *what,
1539 const char *where,
1540 const char *options,
1541 const char *fstype,
1542 bool set_flags) {
1543
1544 _cleanup_free_ char *e = NULL;
1545 MountSetupFlags flags;
1546 Unit *u;
1547 int r;
1548
1549 assert(m);
1550 assert(what);
1551 assert(where);
1552 assert(options);
1553 assert(fstype);
1554
1555 /* Ignore API mount points. They should never be referenced in
1556 * dependencies ever. */
1557 if (mount_point_is_api(where) || mount_point_ignore(where))
1558 return 0;
1559
1560 if (streq(fstype, "autofs"))
1561 return 0;
1562
1563 /* probably some kind of swap, ignore */
1564 if (!is_path(where))
1565 return 0;
1566
1567 r = unit_name_from_path(where, ".mount", &e);
1568 if (r < 0)
1569 return r;
1570
1571 u = manager_get_unit(m, e);
1572 if (!u) {
1573 /* First time we see this mount point meaning that it's
1574 * not been initiated by a mount unit but rather by the
1575 * sysadmin having called mount(8) directly. */
1576 r = unit_new_for_name(m, sizeof(Mount), e, &u);
1577 if (r < 0)
1578 goto fail;
1579
1580 r = mount_setup_new_unit(u, what, where, options, fstype, &flags);
1581 if (r < 0)
1582 unit_free(u);
1583 } else
1584 r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
1585
1586 if (r < 0)
1587 goto fail;
1588
1589 if (set_flags) {
1590 MOUNT(u)->is_mounted = flags.is_mounted;
1591 MOUNT(u)->just_mounted = flags.just_mounted;
1592 MOUNT(u)->just_changed = flags.just_changed;
1593 }
1594
1595 if (flags.just_changed)
1596 unit_add_to_dbus_queue(u);
1597
1598 return 0;
1599 fail:
1600 log_warning_errno(r, "Failed to set up mount unit: %m");
1601 return r;
1602 }
1603
1604 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1605 _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
1606 _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
1607 int r = 0;
1608
1609 assert(m);
1610
1611 t = mnt_new_table();
1612 if (!t)
1613 return log_oom();
1614
1615 i = mnt_new_iter(MNT_ITER_FORWARD);
1616 if (!i)
1617 return log_oom();
1618
1619 r = mnt_table_parse_mtab(t, NULL);
1620 if (r < 0)
1621 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
1622
1623 r = 0;
1624 for (;;) {
1625 const char *device, *path, *options, *fstype;
1626 _cleanup_free_ char *d = NULL, *p = NULL;
1627 struct libmnt_fs *fs;
1628 int k;
1629
1630 k = mnt_table_next_fs(t, i, &fs);
1631 if (k == 1)
1632 break;
1633 if (k < 0)
1634 return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
1635
1636 device = mnt_fs_get_source(fs);
1637 path = mnt_fs_get_target(fs);
1638 options = mnt_fs_get_options(fs);
1639 fstype = mnt_fs_get_fstype(fs);
1640
1641 if (!device || !path)
1642 continue;
1643
1644 if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
1645 return log_oom();
1646
1647 if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
1648 return log_oom();
1649
1650 (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
1651
1652 k = mount_setup_unit(m, d, p, options, fstype, set_flags);
1653 if (r == 0 && k < 0)
1654 r = k;
1655 }
1656
1657 return r;
1658 }
1659
1660 static void mount_shutdown(Manager *m) {
1661 assert(m);
1662
1663 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1664
1665 mnt_unref_monitor(m->mount_monitor);
1666 m->mount_monitor = NULL;
1667 }
1668
1669 static int mount_get_timeout(Unit *u, usec_t *timeout) {
1670 Mount *m = MOUNT(u);
1671 usec_t t;
1672 int r;
1673
1674 if (!m->timer_event_source)
1675 return 0;
1676
1677 r = sd_event_source_get_time(m->timer_event_source, &t);
1678 if (r < 0)
1679 return r;
1680 if (t == USEC_INFINITY)
1681 return 0;
1682
1683 *timeout = t;
1684 return 1;
1685 }
1686
1687 static int synthesize_root_mount(Manager *m) {
1688 Unit *u;
1689 int r;
1690
1691 assert(m);
1692
1693 /* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
1694 * unconditionally synthesize it here and mark it as perpetual. */
1695
1696 u = manager_get_unit(m, SPECIAL_ROOT_MOUNT);
1697 if (!u) {
1698 r = unit_new_for_name(m, sizeof(Mount), SPECIAL_ROOT_MOUNT, &u);
1699 if (r < 0)
1700 return log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
1701 }
1702
1703 u->perpetual = true;
1704 MOUNT(u)->deserialized_state = MOUNT_MOUNTED;
1705
1706 unit_add_to_load_queue(u);
1707 unit_add_to_dbus_queue(u);
1708
1709 return 0;
1710 }
1711
1712 static bool mount_is_mounted(Mount *m) {
1713 assert(m);
1714
1715 return UNIT(m)->perpetual || m->is_mounted;
1716 }
1717
1718 static void mount_enumerate(Manager *m) {
1719 int r;
1720
1721 assert(m);
1722
1723 r = synthesize_root_mount(m);
1724 if (r < 0)
1725 goto fail;
1726
1727 mnt_init_debug(0);
1728
1729 if (!m->mount_monitor) {
1730 int fd;
1731
1732 m->mount_monitor = mnt_new_monitor();
1733 if (!m->mount_monitor) {
1734 log_oom();
1735 goto fail;
1736 }
1737
1738 r = mnt_monitor_enable_kernel(m->mount_monitor, 1);
1739 if (r < 0) {
1740 log_error_errno(r, "Failed to enable watching of kernel mount events: %m");
1741 goto fail;
1742 }
1743
1744 r = mnt_monitor_enable_userspace(m->mount_monitor, 1, NULL);
1745 if (r < 0) {
1746 log_error_errno(r, "Failed to enable watching of userspace mount events: %m");
1747 goto fail;
1748 }
1749
1750 /* mnt_unref_monitor() will close the fd */
1751 fd = r = mnt_monitor_get_fd(m->mount_monitor);
1752 if (r < 0) {
1753 log_error_errno(r, "Failed to acquire watch file descriptor: %m");
1754 goto fail;
1755 }
1756
1757 r = sd_event_add_io(m->event, &m->mount_event_source, fd, EPOLLIN, mount_dispatch_io, m);
1758 if (r < 0) {
1759 log_error_errno(r, "Failed to watch mount file descriptor: %m");
1760 goto fail;
1761 }
1762
1763 r = sd_event_source_set_priority(m->mount_event_source, SD_EVENT_PRIORITY_NORMAL-10);
1764 if (r < 0) {
1765 log_error_errno(r, "Failed to adjust mount watch priority: %m");
1766 goto fail;
1767 }
1768
1769 (void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
1770 }
1771
1772 r = mount_load_proc_self_mountinfo(m, false);
1773 if (r < 0)
1774 goto fail;
1775
1776 return;
1777
1778 fail:
1779 mount_shutdown(m);
1780 }
1781
1782 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1783 _cleanup_set_free_ Set *around = NULL, *gone = NULL;
1784 Manager *m = userdata;
1785 const char *what;
1786 Iterator i;
1787 Unit *u;
1788 int r;
1789
1790 assert(m);
1791 assert(revents & EPOLLIN);
1792
1793 if (fd == mnt_monitor_get_fd(m->mount_monitor)) {
1794 bool rescan = false;
1795
1796 /* Drain all events and verify that the event is valid.
1797 *
1798 * Note that libmount also monitors /run/mount mkdir if the
1799 * directory does not exist yet. The mkdir may generate event
1800 * which is irrelevant for us.
1801 *
1802 * error: r < 0; valid: r == 0, false positive: rc == 1 */
1803 do {
1804 r = mnt_monitor_next_change(m->mount_monitor, NULL, NULL);
1805 if (r == 0)
1806 rescan = true;
1807 else if (r < 0)
1808 return log_error_errno(r, "Failed to drain libmount events");
1809 } while (r == 0);
1810
1811 log_debug("libmount event [rescan: %s]", yes_no(rescan));
1812 if (!rescan)
1813 return 0;
1814 }
1815
1816 r = mount_load_proc_self_mountinfo(m, true);
1817 if (r < 0) {
1818 /* Reset flags, just in case, for later calls */
1819 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1820 Mount *mount = MOUNT(u);
1821
1822 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1823 }
1824
1825 return 0;
1826 }
1827
1828 manager_dispatch_load_queue(m);
1829
1830 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1831 Mount *mount = MOUNT(u);
1832
1833 if (!mount_is_mounted(mount)) {
1834
1835 /* A mount point is not around right now. It
1836 * might be gone, or might never have
1837 * existed. */
1838
1839 if (mount->from_proc_self_mountinfo &&
1840 mount->parameters_proc_self_mountinfo.what) {
1841
1842 /* Remember that this device might just have disappeared */
1843 if (set_ensure_allocated(&gone, &string_hash_ops) < 0 ||
1844 set_put(gone, mount->parameters_proc_self_mountinfo.what) < 0)
1845 log_oom(); /* we don't care too much about OOM here... */
1846 }
1847
1848 mount->from_proc_self_mountinfo = false;
1849
1850 switch (mount->state) {
1851
1852 case MOUNT_MOUNTED:
1853 /* This has just been unmounted by
1854 * somebody else, follow the state
1855 * change. */
1856 mount->result = MOUNT_SUCCESS; /* make sure we forget any earlier umount failures */
1857 mount_enter_dead(mount, MOUNT_SUCCESS);
1858 break;
1859
1860 default:
1861 break;
1862 }
1863
1864 } else if (mount->just_mounted || mount->just_changed) {
1865
1866 /* A mount point was added or changed */
1867
1868 switch (mount->state) {
1869
1870 case MOUNT_DEAD:
1871 case MOUNT_FAILED:
1872
1873 /* This has just been mounted by somebody else, follow the state change, but let's
1874 * generate a new invocation ID for this implicitly and automatically. */
1875 (void) unit_acquire_invocation_id(UNIT(mount));
1876 mount_enter_mounted(mount, MOUNT_SUCCESS);
1877 break;
1878
1879 case MOUNT_MOUNTING:
1880 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1881 break;
1882
1883 default:
1884 /* Nothing really changed, but let's
1885 * issue an notification call
1886 * nonetheless, in case somebody is
1887 * waiting for this. (e.g. file system
1888 * ro/rw remounts.) */
1889 mount_set_state(mount, mount->state);
1890 break;
1891 }
1892 }
1893
1894 if (mount_is_mounted(mount) &&
1895 mount->from_proc_self_mountinfo &&
1896 mount->parameters_proc_self_mountinfo.what) {
1897
1898 if (set_ensure_allocated(&around, &string_hash_ops) < 0 ||
1899 set_put(around, mount->parameters_proc_self_mountinfo.what) < 0)
1900 log_oom();
1901 }
1902
1903 /* Reset the flags for later calls */
1904 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1905 }
1906
1907 SET_FOREACH(what, gone, i) {
1908 if (set_contains(around, what))
1909 continue;
1910
1911 /* Let the device units know that the device is no longer mounted */
1912 (void) device_found_node(m, what, false, DEVICE_FOUND_MOUNT, true);
1913 }
1914
1915 return 0;
1916 }
1917
1918 static void mount_reset_failed(Unit *u) {
1919 Mount *m = MOUNT(u);
1920
1921 assert(m);
1922
1923 if (m->state == MOUNT_FAILED)
1924 mount_set_state(m, MOUNT_DEAD);
1925
1926 m->result = MOUNT_SUCCESS;
1927 m->reload_result = MOUNT_SUCCESS;
1928 }
1929
1930 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1931 Mount *m = MOUNT(u);
1932
1933 assert(m);
1934
1935 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1936 }
1937
1938 static int mount_control_pid(Unit *u) {
1939 Mount *m = MOUNT(u);
1940
1941 assert(m);
1942
1943 return m->control_pid;
1944 }
1945
1946 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1947 [MOUNT_EXEC_MOUNT] = "ExecMount",
1948 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1949 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1950 };
1951
1952 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1953
1954 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1955 [MOUNT_SUCCESS] = "success",
1956 [MOUNT_FAILURE_RESOURCES] = "resources",
1957 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1958 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1959 [MOUNT_FAILURE_SIGNAL] = "signal",
1960 [MOUNT_FAILURE_CORE_DUMP] = "core-dump",
1961 [MOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
1962 [MOUNT_FAILURE_PROTOCOL] = "protocol",
1963 };
1964
1965 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1966
1967 const UnitVTable mount_vtable = {
1968 .object_size = sizeof(Mount),
1969 .exec_context_offset = offsetof(Mount, exec_context),
1970 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1971 .kill_context_offset = offsetof(Mount, kill_context),
1972 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1973 .dynamic_creds_offset = offsetof(Mount, dynamic_creds),
1974
1975 .sections =
1976 "Unit\0"
1977 "Mount\0"
1978 "Install\0",
1979 .private_section = "Mount",
1980
1981 .init = mount_init,
1982 .load = mount_load,
1983 .done = mount_done,
1984
1985 .coldplug = mount_coldplug,
1986
1987 .dump = mount_dump,
1988
1989 .start = mount_start,
1990 .stop = mount_stop,
1991 .reload = mount_reload,
1992
1993 .kill = mount_kill,
1994
1995 .serialize = mount_serialize,
1996 .deserialize_item = mount_deserialize_item,
1997
1998 .active_state = mount_active_state,
1999 .sub_state_to_string = mount_sub_state_to_string,
2000
2001 .may_gc = mount_may_gc,
2002
2003 .sigchld_event = mount_sigchld_event,
2004
2005 .reset_failed = mount_reset_failed,
2006
2007 .control_pid = mount_control_pid,
2008
2009 .bus_vtable = bus_mount_vtable,
2010 .bus_set_property = bus_mount_set_property,
2011 .bus_commit_properties = bus_mount_commit_properties,
2012
2013 .get_timeout = mount_get_timeout,
2014
2015 .can_transient = true,
2016
2017 .enumerate = mount_enumerate,
2018 .shutdown = mount_shutdown,
2019
2020 .status_message_formats = {
2021 .starting_stopping = {
2022 [0] = "Mounting %s...",
2023 [1] = "Unmounting %s...",
2024 },
2025 .finished_start_job = {
2026 [JOB_DONE] = "Mounted %s.",
2027 [JOB_FAILED] = "Failed to mount %s.",
2028 [JOB_TIMEOUT] = "Timed out mounting %s.",
2029 },
2030 .finished_stop_job = {
2031 [JOB_DONE] = "Unmounted %s.",
2032 [JOB_FAILED] = "Failed unmounting %s.",
2033 [JOB_TIMEOUT] = "Timed out unmounting %s.",
2034 },
2035 },
2036 };