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