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