]> 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 #8149 from poettering/fake-root-cgroup
[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 unit_set_exec_params(UNIT(m), &exec_params);
785
786 r = exec_spawn(UNIT(m),
787 c,
788 &m->exec_context,
789 &exec_params,
790 m->exec_runtime,
791 &m->dynamic_creds,
792 &pid);
793 if (r < 0)
794 return r;
795
796 r = unit_watch_pid(UNIT(m), pid);
797 if (r < 0)
798 /* FIXME: we need to do something here */
799 return r;
800
801 *_pid = pid;
802
803 return 0;
804 }
805
806 static void mount_enter_dead(Mount *m, MountResult f) {
807 assert(m);
808
809 if (m->result == MOUNT_SUCCESS)
810 m->result = f;
811
812 if (m->result != MOUNT_SUCCESS)
813 log_unit_warning(UNIT(m), "Failed with result '%s'.", mount_result_to_string(m->result));
814
815 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
816
817 m->exec_runtime = exec_runtime_unref(m->exec_runtime, true);
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_may_gc(Unit *u) {
1237 Mount *m = MOUNT(u);
1238
1239 assert(m);
1240
1241 if (m->from_proc_self_mountinfo)
1242 return false;
1243
1244 return true;
1245 }
1246
1247 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1248 Mount *m = MOUNT(u);
1249 MountResult f;
1250
1251 assert(m);
1252 assert(pid >= 0);
1253
1254 if (pid != m->control_pid)
1255 return;
1256
1257 m->control_pid = 0;
1258
1259 if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
1260 f = MOUNT_SUCCESS;
1261 else if (code == CLD_EXITED)
1262 f = MOUNT_FAILURE_EXIT_CODE;
1263 else if (code == CLD_KILLED)
1264 f = MOUNT_FAILURE_SIGNAL;
1265 else if (code == CLD_DUMPED)
1266 f = MOUNT_FAILURE_CORE_DUMP;
1267 else
1268 assert_not_reached("Unknown code");
1269
1270 if (IN_SET(m->state, MOUNT_REMOUNTING, MOUNT_REMOUNTING_SIGKILL, MOUNT_REMOUNTING_SIGTERM))
1271 mount_set_reload_result(m, f);
1272 else if (m->result == MOUNT_SUCCESS)
1273 m->result = f;
1274
1275 if (m->control_command) {
1276 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1277
1278 m->control_command = NULL;
1279 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1280 }
1281
1282 log_unit_full(u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
1283 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code), status);
1284
1285 /* Note that due to the io event priority logic, we can be sure the new mountinfo is loaded
1286 * before we process the SIGCHLD for the mount command. */
1287
1288 switch (m->state) {
1289
1290 case MOUNT_MOUNTING:
1291 /* Our mount point has not appeared in mountinfo. Something went wrong. */
1292
1293 if (f == MOUNT_SUCCESS) {
1294 /* Either /bin/mount has an unexpected definition of success,
1295 * or someone raced us and we lost. */
1296 log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
1297 f = MOUNT_FAILURE_PROTOCOL;
1298 }
1299 mount_enter_dead(m, f);
1300 break;
1301
1302 case MOUNT_MOUNTING_DONE:
1303 mount_enter_mounted(m, f);
1304 break;
1305
1306 case MOUNT_REMOUNTING:
1307 case MOUNT_REMOUNTING_SIGTERM:
1308 case MOUNT_REMOUNTING_SIGKILL:
1309 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1310 break;
1311
1312 case MOUNT_UNMOUNTING:
1313
1314 if (f == MOUNT_SUCCESS && m->from_proc_self_mountinfo) {
1315
1316 /* Still a mount point? If so, let's try again. Most likely there were multiple mount points
1317 * stacked on top of each other. We might exceed the timeout specified by the user overall,
1318 * but we will stop as soon as any one umount times out. */
1319
1320 if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
1321 log_unit_debug(u, "Mount still present, trying again.");
1322 m->n_retry_umount++;
1323 mount_enter_unmounting(m);
1324 } else {
1325 log_unit_warning(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
1326 mount_enter_mounted(m, f);
1327 }
1328 } else
1329 mount_enter_dead_or_mounted(m, f);
1330
1331 break;
1332
1333 case MOUNT_UNMOUNTING_SIGKILL:
1334 case MOUNT_UNMOUNTING_SIGTERM:
1335 mount_enter_dead_or_mounted(m, f);
1336 break;
1337
1338 default:
1339 assert_not_reached("Uh, control process died at wrong time.");
1340 }
1341
1342 /* Notify clients about changed exit status */
1343 unit_add_to_dbus_queue(u);
1344 }
1345
1346 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1347 Mount *m = MOUNT(userdata);
1348
1349 assert(m);
1350 assert(m->timer_event_source == source);
1351
1352 switch (m->state) {
1353
1354 case MOUNT_MOUNTING:
1355 case MOUNT_MOUNTING_DONE:
1356 log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
1357 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1358 break;
1359
1360 case MOUNT_REMOUNTING:
1361 log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
1362 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1363 mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
1364 break;
1365
1366 case MOUNT_REMOUNTING_SIGTERM:
1367 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1368
1369 if (m->kill_context.send_sigkill) {
1370 log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
1371 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
1372 } else {
1373 log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1374 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1375 }
1376 break;
1377
1378 case MOUNT_REMOUNTING_SIGKILL:
1379 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1380
1381 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1382 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1383 break;
1384
1385 case MOUNT_UNMOUNTING:
1386 log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
1387 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1388 break;
1389
1390 case MOUNT_UNMOUNTING_SIGTERM:
1391 if (m->kill_context.send_sigkill) {
1392 log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
1393 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1394 } else {
1395 log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
1396 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1397 }
1398 break;
1399
1400 case MOUNT_UNMOUNTING_SIGKILL:
1401 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1402 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1403 break;
1404
1405 default:
1406 assert_not_reached("Timeout at wrong time.");
1407 }
1408
1409 return 0;
1410 }
1411
1412 typedef struct {
1413 bool is_mounted;
1414 bool just_mounted;
1415 bool just_changed;
1416 } MountSetupFlags;
1417
1418 static int mount_setup_new_unit(
1419 Unit *u,
1420 const char *what,
1421 const char *where,
1422 const char *options,
1423 const char *fstype,
1424 MountSetupFlags *flags) {
1425
1426 MountParameters *p;
1427
1428 assert(u);
1429 assert(flags);
1430
1431 u->source_path = strdup("/proc/self/mountinfo");
1432 MOUNT(u)->where = strdup(where);
1433 if (!u->source_path || !MOUNT(u)->where)
1434 return -ENOMEM;
1435
1436 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1437 MOUNT(u)->from_proc_self_mountinfo = true;
1438 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1439
1440 p->what = strdup(what);
1441 p->options = strdup(options);
1442 p->fstype = strdup(fstype);
1443 if (!p->what || !p->options || !p->fstype)
1444 return -ENOMEM;
1445
1446 if (!mount_is_extrinsic(MOUNT(u))) {
1447 const char *target;
1448 int r;
1449
1450 target = mount_is_network(p) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1451 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1452 if (r < 0)
1453 return r;
1454
1455 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1456 if (r < 0)
1457 return r;
1458 }
1459
1460 unit_add_to_load_queue(u);
1461 flags->is_mounted = true;
1462 flags->just_mounted = true;
1463 flags->just_changed = true;
1464
1465 return 0;
1466 }
1467
1468 static int mount_setup_existing_unit(
1469 Unit *u,
1470 const char *what,
1471 const char *where,
1472 const char *options,
1473 const char *fstype,
1474 MountSetupFlags *flags) {
1475
1476 MountParameters *p;
1477 bool load_extras = false;
1478 int r1, r2, r3;
1479
1480 assert(u);
1481 assert(flags);
1482
1483 if (!MOUNT(u)->where) {
1484 MOUNT(u)->where = strdup(where);
1485 if (!MOUNT(u)->where)
1486 return -ENOMEM;
1487 }
1488
1489 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1490 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1491
1492 r1 = free_and_strdup(&p->what, what);
1493 r2 = free_and_strdup(&p->options, options);
1494 r3 = free_and_strdup(&p->fstype, fstype);
1495 if (r1 < 0 || r2 < 0 || r3 < 0)
1496 return -ENOMEM;
1497
1498 flags->just_changed = r1 > 0 || r2 > 0 || r3 > 0;
1499 flags->is_mounted = true;
1500 flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
1501
1502 MOUNT(u)->from_proc_self_mountinfo = true;
1503
1504 if (!mount_is_extrinsic(MOUNT(u)) && mount_is_network(p)) {
1505 /* _netdev option may have shown up late, or on a
1506 * remount. Add remote-fs dependencies, even though
1507 * local-fs ones may already be there.
1508 *
1509 * Note: due to a current limitation (we don't track
1510 * in the dependency "Set*" objects who created a
1511 * dependency), we can only add deps, never lose them,
1512 * until the next full daemon-reload. */
1513 unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1514 load_extras = true;
1515 }
1516
1517 if (u->load_state == UNIT_NOT_FOUND) {
1518 u->load_state = UNIT_LOADED;
1519 u->load_error = 0;
1520
1521 /* Load in the extras later on, after we
1522 * finished initialization of the unit */
1523
1524 /* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
1525 load_extras = true;
1526 flags->just_changed = true;
1527 }
1528
1529 if (load_extras)
1530 return mount_add_extras(MOUNT(u));
1531
1532 return 0;
1533 }
1534
1535 static int mount_setup_unit(
1536 Manager *m,
1537 const char *what,
1538 const char *where,
1539 const char *options,
1540 const char *fstype,
1541 bool set_flags) {
1542
1543 _cleanup_free_ char *e = NULL;
1544 MountSetupFlags flags;
1545 Unit *u;
1546 int r;
1547
1548 assert(m);
1549 assert(what);
1550 assert(where);
1551 assert(options);
1552 assert(fstype);
1553
1554 /* Ignore API mount points. They should never be referenced in
1555 * dependencies ever. */
1556 if (mount_point_is_api(where) || mount_point_ignore(where))
1557 return 0;
1558
1559 if (streq(fstype, "autofs"))
1560 return 0;
1561
1562 /* probably some kind of swap, ignore */
1563 if (!is_path(where))
1564 return 0;
1565
1566 r = unit_name_from_path(where, ".mount", &e);
1567 if (r < 0)
1568 return r;
1569
1570 u = manager_get_unit(m, e);
1571 if (!u) {
1572 /* First time we see this mount point meaning that it's
1573 * not been initiated by a mount unit but rather by the
1574 * sysadmin having called mount(8) directly. */
1575 r = unit_new_for_name(m, sizeof(Mount), e, &u);
1576 if (r < 0)
1577 goto fail;
1578
1579 r = mount_setup_new_unit(u, what, where, options, fstype, &flags);
1580 if (r < 0)
1581 unit_free(u);
1582 } else
1583 r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
1584
1585 if (r < 0)
1586 goto fail;
1587
1588 if (set_flags) {
1589 MOUNT(u)->is_mounted = flags.is_mounted;
1590 MOUNT(u)->just_mounted = flags.just_mounted;
1591 MOUNT(u)->just_changed = flags.just_changed;
1592 }
1593
1594 if (flags.just_changed)
1595 unit_add_to_dbus_queue(u);
1596
1597 return 0;
1598 fail:
1599 log_warning_errno(r, "Failed to set up mount unit: %m");
1600 return r;
1601 }
1602
1603 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1604 _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
1605 _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
1606 int r = 0;
1607
1608 assert(m);
1609
1610 t = mnt_new_table();
1611 if (!t)
1612 return log_oom();
1613
1614 i = mnt_new_iter(MNT_ITER_FORWARD);
1615 if (!i)
1616 return log_oom();
1617
1618 r = mnt_table_parse_mtab(t, NULL);
1619 if (r < 0)
1620 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
1621
1622 r = 0;
1623 for (;;) {
1624 const char *device, *path, *options, *fstype;
1625 _cleanup_free_ char *d = NULL, *p = NULL;
1626 struct libmnt_fs *fs;
1627 int k;
1628
1629 k = mnt_table_next_fs(t, i, &fs);
1630 if (k == 1)
1631 break;
1632 if (k < 0)
1633 return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
1634
1635 device = mnt_fs_get_source(fs);
1636 path = mnt_fs_get_target(fs);
1637 options = mnt_fs_get_options(fs);
1638 fstype = mnt_fs_get_fstype(fs);
1639
1640 if (!device || !path)
1641 continue;
1642
1643 if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
1644 return log_oom();
1645
1646 if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
1647 return log_oom();
1648
1649 (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
1650
1651 k = mount_setup_unit(m, d, p, options, fstype, set_flags);
1652 if (r == 0 && k < 0)
1653 r = k;
1654 }
1655
1656 return r;
1657 }
1658
1659 static void mount_shutdown(Manager *m) {
1660 assert(m);
1661
1662 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1663
1664 mnt_unref_monitor(m->mount_monitor);
1665 m->mount_monitor = NULL;
1666 }
1667
1668 static int mount_get_timeout(Unit *u, usec_t *timeout) {
1669 Mount *m = MOUNT(u);
1670 usec_t t;
1671 int r;
1672
1673 if (!m->timer_event_source)
1674 return 0;
1675
1676 r = sd_event_source_get_time(m->timer_event_source, &t);
1677 if (r < 0)
1678 return r;
1679 if (t == USEC_INFINITY)
1680 return 0;
1681
1682 *timeout = t;
1683 return 1;
1684 }
1685
1686 static int synthesize_root_mount(Manager *m) {
1687 Unit *u;
1688 int r;
1689
1690 assert(m);
1691
1692 /* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
1693 * unconditionally synthesize it here and mark it as perpetual. */
1694
1695 u = manager_get_unit(m, SPECIAL_ROOT_MOUNT);
1696 if (!u) {
1697 r = unit_new_for_name(m, sizeof(Mount), SPECIAL_ROOT_MOUNT, &u);
1698 if (r < 0)
1699 return log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
1700 }
1701
1702 u->perpetual = true;
1703 MOUNT(u)->deserialized_state = MOUNT_MOUNTED;
1704
1705 unit_add_to_load_queue(u);
1706 unit_add_to_dbus_queue(u);
1707
1708 return 0;
1709 }
1710
1711 static bool mount_is_mounted(Mount *m) {
1712 assert(m);
1713
1714 return UNIT(m)->perpetual || m->is_mounted;
1715 }
1716
1717 static void mount_enumerate(Manager *m) {
1718 int r;
1719
1720 assert(m);
1721
1722 r = synthesize_root_mount(m);
1723 if (r < 0)
1724 goto fail;
1725
1726 mnt_init_debug(0);
1727
1728 if (!m->mount_monitor) {
1729 int fd;
1730
1731 m->mount_monitor = mnt_new_monitor();
1732 if (!m->mount_monitor) {
1733 log_oom();
1734 goto fail;
1735 }
1736
1737 r = mnt_monitor_enable_kernel(m->mount_monitor, 1);
1738 if (r < 0) {
1739 log_error_errno(r, "Failed to enable watching of kernel mount events: %m");
1740 goto fail;
1741 }
1742
1743 r = mnt_monitor_enable_userspace(m->mount_monitor, 1, NULL);
1744 if (r < 0) {
1745 log_error_errno(r, "Failed to enable watching of userspace mount events: %m");
1746 goto fail;
1747 }
1748
1749 /* mnt_unref_monitor() will close the fd */
1750 fd = r = mnt_monitor_get_fd(m->mount_monitor);
1751 if (r < 0) {
1752 log_error_errno(r, "Failed to acquire watch file descriptor: %m");
1753 goto fail;
1754 }
1755
1756 r = sd_event_add_io(m->event, &m->mount_event_source, fd, EPOLLIN, mount_dispatch_io, m);
1757 if (r < 0) {
1758 log_error_errno(r, "Failed to watch mount file descriptor: %m");
1759 goto fail;
1760 }
1761
1762 r = sd_event_source_set_priority(m->mount_event_source, SD_EVENT_PRIORITY_NORMAL-10);
1763 if (r < 0) {
1764 log_error_errno(r, "Failed to adjust mount watch priority: %m");
1765 goto fail;
1766 }
1767
1768 (void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
1769 }
1770
1771 r = mount_load_proc_self_mountinfo(m, false);
1772 if (r < 0)
1773 goto fail;
1774
1775 return;
1776
1777 fail:
1778 mount_shutdown(m);
1779 }
1780
1781 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1782 _cleanup_set_free_ Set *around = NULL, *gone = NULL;
1783 Manager *m = userdata;
1784 const char *what;
1785 Iterator i;
1786 Unit *u;
1787 int r;
1788
1789 assert(m);
1790 assert(revents & EPOLLIN);
1791
1792 if (fd == mnt_monitor_get_fd(m->mount_monitor)) {
1793 bool rescan = false;
1794
1795 /* Drain all events and verify that the event is valid.
1796 *
1797 * Note that libmount also monitors /run/mount mkdir if the
1798 * directory does not exist yet. The mkdir may generate event
1799 * which is irrelevant for us.
1800 *
1801 * error: r < 0; valid: r == 0, false positive: rc == 1 */
1802 do {
1803 r = mnt_monitor_next_change(m->mount_monitor, NULL, NULL);
1804 if (r == 0)
1805 rescan = true;
1806 else if (r < 0)
1807 return log_error_errno(r, "Failed to drain libmount events");
1808 } while (r == 0);
1809
1810 log_debug("libmount event [rescan: %s]", yes_no(rescan));
1811 if (!rescan)
1812 return 0;
1813 }
1814
1815 r = mount_load_proc_self_mountinfo(m, true);
1816 if (r < 0) {
1817 /* Reset flags, just in case, for later calls */
1818 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1819 Mount *mount = MOUNT(u);
1820
1821 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1822 }
1823
1824 return 0;
1825 }
1826
1827 manager_dispatch_load_queue(m);
1828
1829 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1830 Mount *mount = MOUNT(u);
1831
1832 if (!mount_is_mounted(mount)) {
1833
1834 /* A mount point is not around right now. It
1835 * might be gone, or might never have
1836 * existed. */
1837
1838 if (mount->from_proc_self_mountinfo &&
1839 mount->parameters_proc_self_mountinfo.what) {
1840
1841 /* Remember that this device might just have disappeared */
1842 if (set_ensure_allocated(&gone, &path_hash_ops) < 0 ||
1843 set_put(gone, mount->parameters_proc_self_mountinfo.what) < 0)
1844 log_oom(); /* we don't care too much about OOM here... */
1845 }
1846
1847 mount->from_proc_self_mountinfo = false;
1848
1849 switch (mount->state) {
1850
1851 case MOUNT_MOUNTED:
1852 /* This has just been unmounted by
1853 * somebody else, follow the state
1854 * change. */
1855 mount->result = MOUNT_SUCCESS; /* make sure we forget any earlier umount failures */
1856 mount_enter_dead(mount, MOUNT_SUCCESS);
1857 break;
1858
1859 default:
1860 break;
1861 }
1862
1863 } else if (mount->just_mounted || mount->just_changed) {
1864
1865 /* A mount point was added or changed */
1866
1867 switch (mount->state) {
1868
1869 case MOUNT_DEAD:
1870 case MOUNT_FAILED:
1871
1872 /* This has just been mounted by somebody else, follow the state change, but let's
1873 * generate a new invocation ID for this implicitly and automatically. */
1874 (void) unit_acquire_invocation_id(UNIT(mount));
1875 mount_enter_mounted(mount, MOUNT_SUCCESS);
1876 break;
1877
1878 case MOUNT_MOUNTING:
1879 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1880 break;
1881
1882 default:
1883 /* Nothing really changed, but let's
1884 * issue an notification call
1885 * nonetheless, in case somebody is
1886 * waiting for this. (e.g. file system
1887 * ro/rw remounts.) */
1888 mount_set_state(mount, mount->state);
1889 break;
1890 }
1891 }
1892
1893 if (mount_is_mounted(mount) &&
1894 mount->from_proc_self_mountinfo &&
1895 mount->parameters_proc_self_mountinfo.what) {
1896
1897 if (set_ensure_allocated(&around, &path_hash_ops) < 0 ||
1898 set_put(around, mount->parameters_proc_self_mountinfo.what) < 0)
1899 log_oom();
1900 }
1901
1902 /* Reset the flags for later calls */
1903 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1904 }
1905
1906 SET_FOREACH(what, gone, i) {
1907 if (set_contains(around, what))
1908 continue;
1909
1910 /* Let the device units know that the device is no longer mounted */
1911 (void) device_found_node(m, what, false, DEVICE_FOUND_MOUNT, true);
1912 }
1913
1914 return 0;
1915 }
1916
1917 static void mount_reset_failed(Unit *u) {
1918 Mount *m = MOUNT(u);
1919
1920 assert(m);
1921
1922 if (m->state == MOUNT_FAILED)
1923 mount_set_state(m, MOUNT_DEAD);
1924
1925 m->result = MOUNT_SUCCESS;
1926 m->reload_result = MOUNT_SUCCESS;
1927 }
1928
1929 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1930 Mount *m = MOUNT(u);
1931
1932 assert(m);
1933
1934 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1935 }
1936
1937 static int mount_control_pid(Unit *u) {
1938 Mount *m = MOUNT(u);
1939
1940 assert(m);
1941
1942 return m->control_pid;
1943 }
1944
1945 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1946 [MOUNT_EXEC_MOUNT] = "ExecMount",
1947 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1948 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1949 };
1950
1951 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1952
1953 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1954 [MOUNT_SUCCESS] = "success",
1955 [MOUNT_FAILURE_RESOURCES] = "resources",
1956 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1957 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1958 [MOUNT_FAILURE_SIGNAL] = "signal",
1959 [MOUNT_FAILURE_CORE_DUMP] = "core-dump",
1960 [MOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
1961 [MOUNT_FAILURE_PROTOCOL] = "protocol",
1962 };
1963
1964 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1965
1966 const UnitVTable mount_vtable = {
1967 .object_size = sizeof(Mount),
1968 .exec_context_offset = offsetof(Mount, exec_context),
1969 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1970 .kill_context_offset = offsetof(Mount, kill_context),
1971 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1972 .dynamic_creds_offset = offsetof(Mount, dynamic_creds),
1973
1974 .sections =
1975 "Unit\0"
1976 "Mount\0"
1977 "Install\0",
1978 .private_section = "Mount",
1979
1980 .init = mount_init,
1981 .load = mount_load,
1982 .done = mount_done,
1983
1984 .coldplug = mount_coldplug,
1985
1986 .dump = mount_dump,
1987
1988 .start = mount_start,
1989 .stop = mount_stop,
1990 .reload = mount_reload,
1991
1992 .kill = mount_kill,
1993
1994 .serialize = mount_serialize,
1995 .deserialize_item = mount_deserialize_item,
1996
1997 .active_state = mount_active_state,
1998 .sub_state_to_string = mount_sub_state_to_string,
1999
2000 .may_gc = mount_may_gc,
2001
2002 .sigchld_event = mount_sigchld_event,
2003
2004 .reset_failed = mount_reset_failed,
2005
2006 .control_pid = mount_control_pid,
2007
2008 .bus_vtable = bus_mount_vtable,
2009 .bus_set_property = bus_mount_set_property,
2010 .bus_commit_properties = bus_mount_commit_properties,
2011
2012 .get_timeout = mount_get_timeout,
2013
2014 .can_transient = true,
2015
2016 .enumerate = mount_enumerate,
2017 .shutdown = mount_shutdown,
2018
2019 .status_message_formats = {
2020 .starting_stopping = {
2021 [0] = "Mounting %s...",
2022 [1] = "Unmounting %s...",
2023 },
2024 .finished_start_job = {
2025 [JOB_DONE] = "Mounted %s.",
2026 [JOB_FAILED] = "Failed to mount %s.",
2027 [JOB_TIMEOUT] = "Timed out mounting %s.",
2028 },
2029 .finished_stop_job = {
2030 [JOB_DONE] = "Unmounted %s.",
2031 [JOB_FAILED] = "Failed unmounting %s.",
2032 [JOB_TIMEOUT] = "Timed out unmounting %s.",
2033 },
2034 },
2035 };
Unnamed repository; edit this file 'description' to name the repository.