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