]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/mount.c
projects / thirdparty / systemd.git / blob
? search:


453a83f93d422679ceb4a3eb6bfe43a8627ab7df
[thirdparty/systemd.git] / src / core / mount.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2010 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <errno.h>
22 #include <signal.h>
23 #include <stdio.h>
24 #include <sys/epoll.h>
25
26 #include "sd-messages.h"
27
28 #include "alloc-util.h"
29 #include "dbus-mount.h"
30 #include "escape.h"
31 #include "exit-status.h"
32 #include "format-util.h"
33 #include "fstab-util.h"
34 #include "log.h"
35 #include "manager.h"
36 #include "mkdir.h"
37 #include "mount-setup.h"
38 #include "mount-util.h"
39 #include "mount.h"
40 #include "parse-util.h"
41 #include "path-util.h"
42 #include "process-util.h"
43 #include "special.h"
44 #include "string-table.h"
45 #include "string-util.h"
46 #include "strv.h"
47 #include "unit-name.h"
48 #include "unit.h"
49
50 #define RETRY_UMOUNT_MAX 32
51
52 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
53 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
54
55 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
56 [MOUNT_DEAD] = UNIT_INACTIVE,
57 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
58 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVATING,
59 [MOUNT_MOUNTED] = UNIT_ACTIVE,
60 [MOUNT_REMOUNTING] = UNIT_RELOADING,
61 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
62 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
63 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
64 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
65 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
66 [MOUNT_FAILED] = UNIT_FAILED
67 };
68
69 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
70 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
71
72 static bool MOUNT_STATE_WITH_PROCESS(MountState state) {
73 return IN_SET(state,
74 MOUNT_MOUNTING,
75 MOUNT_MOUNTING_DONE,
76 MOUNT_REMOUNTING,
77 MOUNT_REMOUNTING_SIGTERM,
78 MOUNT_REMOUNTING_SIGKILL,
79 MOUNT_UNMOUNTING,
80 MOUNT_UNMOUNTING_SIGTERM,
81 MOUNT_UNMOUNTING_SIGKILL);
82 }
83
84 static bool mount_needs_network(const char *options, const char *fstype) {
85 if (fstab_test_option(options, "_netdev\0"))
86 return true;
87
88 if (fstype && fstype_is_network(fstype))
89 return true;
90
91 return false;
92 }
93
94 static bool mount_is_network(const MountParameters *p) {
95 assert(p);
96
97 return mount_needs_network(p->options, p->fstype);
98 }
99
100 static bool mount_is_loop(const MountParameters *p) {
101 assert(p);
102
103 if (fstab_test_option(p->options, "loop\0"))
104 return true;
105
106 return false;
107 }
108
109 static bool mount_is_bind(const MountParameters *p) {
110 assert(p);
111
112 if (fstab_test_option(p->options, "bind\0" "rbind\0"))
113 return true;
114
115 if (p->fstype && STR_IN_SET(p->fstype, "bind", "rbind"))
116 return true;
117
118 return false;
119 }
120
121 static bool mount_is_auto(const MountParameters *p) {
122 assert(p);
123
124 return !fstab_test_option(p->options, "noauto\0");
125 }
126
127 static bool mount_is_automount(const MountParameters *p) {
128 assert(p);
129
130 return fstab_test_option(p->options,
131 "comment=systemd.automount\0"
132 "x-systemd.automount\0");
133 }
134
135 static bool mount_is_bound_to_device(const Mount *m) {
136 const MountParameters *p;
137
138 if (m->from_fragment)
139 return true;
140
141 p = &m->parameters_proc_self_mountinfo;
142 return fstab_test_option(p->options, "x-systemd.device-bound\0");
143 }
144
145 static bool needs_quota(const MountParameters *p) {
146 assert(p);
147
148 /* Quotas are not enabled on network filesystems,
149 * but we want them, for example, on storage connected via iscsi */
150 if (p->fstype && fstype_is_network(p->fstype))
151 return false;
152
153 if (mount_is_bind(p))
154 return false;
155
156 return fstab_test_option(p->options,
157 "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
158 }
159
160 static void mount_init(Unit *u) {
161 Mount *m = MOUNT(u);
162
163 assert(u);
164 assert(u->load_state == UNIT_STUB);
165
166 m->timeout_usec = u->manager->default_timeout_start_usec;
167
168 m->exec_context.std_output = u->manager->default_std_output;
169 m->exec_context.std_error = u->manager->default_std_error;
170
171 m->directory_mode = 0755;
172
173 /* We need to make sure that /usr/bin/mount is always called
174 * in the same process group as us, so that the autofs kernel
175 * side doesn't send us another mount request while we are
176 * already trying to comply its last one. */
177 m->exec_context.same_pgrp = true;
178
179 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
180
181 u->ignore_on_isolate = true;
182 }
183
184 static int mount_arm_timer(Mount *m, usec_t usec) {
185 int r;
186
187 assert(m);
188
189 if (m->timer_event_source) {
190 r = sd_event_source_set_time(m->timer_event_source, usec);
191 if (r < 0)
192 return r;
193
194 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
195 }
196
197 if (usec == USEC_INFINITY)
198 return 0;
199
200 r = sd_event_add_time(
201 UNIT(m)->manager->event,
202 &m->timer_event_source,
203 CLOCK_MONOTONIC,
204 usec, 0,
205 mount_dispatch_timer, m);
206 if (r < 0)
207 return r;
208
209 (void) sd_event_source_set_description(m->timer_event_source, "mount-timer");
210
211 return 0;
212 }
213
214 static void mount_unwatch_control_pid(Mount *m) {
215 assert(m);
216
217 if (m->control_pid <= 0)
218 return;
219
220 unit_unwatch_pid(UNIT(m), m->control_pid);
221 m->control_pid = 0;
222 }
223
224 static void mount_parameters_done(MountParameters *p) {
225 assert(p);
226
227 free(p->what);
228 free(p->options);
229 free(p->fstype);
230
231 p->what = p->options = p->fstype = NULL;
232 }
233
234 static void mount_done(Unit *u) {
235 Mount *m = MOUNT(u);
236
237 assert(m);
238
239 m->where = mfree(m->where);
240
241 mount_parameters_done(&m->parameters_proc_self_mountinfo);
242 mount_parameters_done(&m->parameters_fragment);
243
244 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
245 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
246 m->control_command = NULL;
247
248 dynamic_creds_unref(&m->dynamic_creds);
249
250 mount_unwatch_control_pid(m);
251
252 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
253 }
254
255 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
256 assert(m);
257
258 if (m->from_fragment)
259 return &m->parameters_fragment;
260
261 return NULL;
262 }
263
264 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
265 assert(m);
266
267 if (m->from_proc_self_mountinfo)
268 return &m->parameters_proc_self_mountinfo;
269
270 return get_mount_parameters_fragment(m);
271 }
272
273 static int mount_add_mount_dependencies(Mount *m) {
274 MountParameters *pm;
275 Unit *other;
276 Iterator i;
277 Set *s;
278 int r;
279
280 assert(m);
281
282 if (!path_equal(m->where, "/")) {
283 _cleanup_free_ char *parent = NULL;
284
285 /* Adds in links to other mount points that might lie further up in the hierarchy */
286
287 parent = dirname_malloc(m->where);
288 if (!parent)
289 return -ENOMEM;
290
291 r = unit_require_mounts_for(UNIT(m), parent, UNIT_DEPENDENCY_IMPLICIT);
292 if (r < 0)
293 return r;
294 }
295
296 /* Adds in dependencies to other mount points that might be needed for the source path (if this is a bind mount
297 * or a loop mount) to be available. */
298 pm = get_mount_parameters_fragment(m);
299 if (pm && pm->what &&
300 path_is_absolute(pm->what) &&
301 (mount_is_bind(pm) || mount_is_loop(pm) || !mount_is_network(pm))) {
302
303 r = unit_require_mounts_for(UNIT(m), pm->what, UNIT_DEPENDENCY_FILE);
304 if (r < 0)
305 return r;
306 }
307
308 /* Adds in dependencies to other units that use this path or paths further down in the hierarchy */
309 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
310 SET_FOREACH(other, s, i) {
311
312 if (other->load_state != UNIT_LOADED)
313 continue;
314
315 if (other == UNIT(m))
316 continue;
317
318 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true, UNIT_DEPENDENCY_PATH);
319 if (r < 0)
320 return r;
321
322 if (UNIT(m)->fragment_path) {
323 /* If we have fragment configuration, then make this dependency required */
324 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true, UNIT_DEPENDENCY_PATH);
325 if (r < 0)
326 return r;
327 }
328 }
329
330 return 0;
331 }
332
333 static int mount_add_device_dependencies(Mount *m) {
334 bool device_wants_mount = false;
335 UnitDependencyMask mask;
336 MountParameters *p;
337 UnitDependency dep;
338 int r;
339
340 assert(m);
341
342 p = get_mount_parameters(m);
343 if (!p)
344 return 0;
345
346 if (!p->what)
347 return 0;
348
349 if (mount_is_bind(p))
350 return 0;
351
352 if (!is_device_path(p->what))
353 return 0;
354
355 /* /dev/root is a really weird thing, it's not a real device,
356 * but just a path the kernel exports for the root file system
357 * specified on the kernel command line. Ignore it here. */
358 if (path_equal(p->what, "/dev/root"))
359 return 0;
360
361 if (path_equal(m->where, "/"))
362 return 0;
363
364 if (mount_is_auto(p) && !mount_is_automount(p) && MANAGER_IS_SYSTEM(UNIT(m)->manager))
365 device_wants_mount = true;
366
367 /* Mount units from /proc/self/mountinfo are not bound to devices
368 * by default since they're subject to races when devices are
369 * unplugged. But the user can still force this dep with an
370 * appropriate option (or udev property) so the mount units are
371 * automatically stopped when the device disappears suddenly. */
372 dep = mount_is_bound_to_device(m) ? UNIT_BINDS_TO : UNIT_REQUIRES;
373
374 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
375
376 r = unit_add_node_dependency(UNIT(m), p->what, device_wants_mount, dep, mask);
377 if (r < 0)
378 return r;
379
380 return 0;
381 }
382
383 static int mount_add_quota_dependencies(Mount *m) {
384 UnitDependencyMask mask;
385 MountParameters *p;
386 int r;
387
388 assert(m);
389
390 if (!MANAGER_IS_SYSTEM(UNIT(m)->manager))
391 return 0;
392
393 p = get_mount_parameters_fragment(m);
394 if (!p)
395 return 0;
396
397 if (!needs_quota(p))
398 return 0;
399
400 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
401
402 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true, mask);
403 if (r < 0)
404 return r;
405
406 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true, mask);
407 if (r < 0)
408 return r;
409
410 return 0;
411 }
412
413 static bool mount_is_extrinsic(Mount *m) {
414 MountParameters *p;
415 assert(m);
416
417 /* Returns true for all units that are "magic" and should be excluded from the usual start-up and shutdown
418 * dependencies. We call them "extrinsic" here, as they are generally mounted outside of the systemd dependency
419 * logic. We shouldn't attempt to manage them ourselves but it's fine if the user operates on them with us. */
420
421 if (!MANAGER_IS_SYSTEM(UNIT(m)->manager)) /* We only automatically manage mounts if we are in system mode */
422 return true;
423
424 if (PATH_IN_SET(m->where, /* Don't bother with the OS data itself */
425 "/",
426 "/usr"))
427 return true;
428
429 if (PATH_STARTSWITH_SET(m->where,
430 "/run/initramfs", /* This should stay around from before we boot until after we shutdown */
431 "/proc", /* All of this is API VFS */
432 "/sys", /* … dito … */
433 "/dev")) /* … dito … */
434 return true;
435
436 /* If this is an initrd mount, and we are not in the initrd, then leave this around forever, too. */
437 p = get_mount_parameters(m);
438 if (p && fstab_test_option(p->options, "x-initrd.mount\0") && !in_initrd())
439 return true;
440
441 return false;
442 }
443
444 static int mount_add_default_dependencies(Mount *m) {
445 UnitDependencyMask mask;
446 int r;
447 MountParameters *p;
448 const char *after;
449
450 assert(m);
451
452 if (!UNIT(m)->default_dependencies)
453 return 0;
454
455 /* We do not add any default dependencies to /, /usr or /run/initramfs/, since they are guaranteed to stay
456 * mounted the whole time, since our system is on it. Also, don't bother with anything mounted below virtual
457 * file systems, it's also going to be virtual, and hence not worth the effort. */
458 if (mount_is_extrinsic(m))
459 return 0;
460
461 p = get_mount_parameters(m);
462 if (!p)
463 return 0;
464
465 mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_DEFAULT;
466
467 if (mount_is_network(p)) {
468 /* We order ourselves after network.target. This is
469 * primarily useful at shutdown: services that take
470 * down the network should order themselves before
471 * network.target, so that they are shut down only
472 * after this mount unit is stopped. */
473
474 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_NETWORK_TARGET, NULL, true, mask);
475 if (r < 0)
476 return r;
477
478 /* We pull in network-online.target, and order
479 * ourselves after it. This is useful at start-up to
480 * actively pull in tools that want to be started
481 * before we start mounting network file systems, and
482 * whose purpose it is to delay this until the network
483 * is "up". */
484
485 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, SPECIAL_NETWORK_ONLINE_TARGET, NULL, true, mask);
486 if (r < 0)
487 return r;
488
489 after = SPECIAL_REMOTE_FS_PRE_TARGET;
490 } else
491 after = SPECIAL_LOCAL_FS_PRE_TARGET;
492
493 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true, mask);
494 if (r < 0)
495 return r;
496
497 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, mask);
498 if (r < 0)
499 return r;
500
501 /* If this is a tmpfs mount then we have to unmount it before we try to deactivate swaps */
502 if (streq_ptr(p->fstype, "tmpfs")) {
503 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_SWAP_TARGET, NULL, true, mask);
504 if (r < 0)
505 return r;
506 }
507
508 return 0;
509 }
510
511 static int mount_verify(Mount *m) {
512 _cleanup_free_ char *e = NULL;
513 MountParameters *p;
514 int r;
515
516 assert(m);
517
518 if (UNIT(m)->load_state != UNIT_LOADED)
519 return 0;
520
521 if (!m->from_fragment && !m->from_proc_self_mountinfo && !UNIT(m)->perpetual)
522 return -ENOENT;
523
524 r = unit_name_from_path(m->where, ".mount", &e);
525 if (r < 0)
526 return log_unit_error_errno(UNIT(m), r, "Failed to generate unit name from mount path: %m");
527
528 if (!unit_has_name(UNIT(m), e)) {
529 log_unit_error(UNIT(m), "Where= setting doesn't match unit name. Refusing.");
530 return -EINVAL;
531 }
532
533 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
534 log_unit_error(UNIT(m), "Cannot create mount unit for API file system %s. Refusing.", m->where);
535 return -EINVAL;
536 }
537
538 p = get_mount_parameters_fragment(m);
539 if (p && !p->what) {
540 log_unit_error(UNIT(m), "What= setting is missing. Refusing.");
541 return -EBADMSG;
542 }
543
544 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
545 log_unit_error(UNIT(m), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
546 return -EINVAL;
547 }
548
549 return 0;
550 }
551
552 static int mount_add_extras(Mount *m) {
553 Unit *u = UNIT(m);
554 int r;
555
556 assert(m);
557
558 if (u->fragment_path)
559 m->from_fragment = true;
560
561 if (!m->where) {
562 r = unit_name_to_path(u->id, &m->where);
563 if (r < 0)
564 return r;
565 }
566
567 path_kill_slashes(m->where);
568
569 if (!u->description) {
570 r = unit_set_description(u, m->where);
571 if (r < 0)
572 return r;
573 }
574
575 r = mount_add_device_dependencies(m);
576 if (r < 0)
577 return r;
578
579 r = mount_add_mount_dependencies(m);
580 if (r < 0)
581 return r;
582
583 r = mount_add_quota_dependencies(m);
584 if (r < 0)
585 return r;
586
587 r = unit_patch_contexts(u);
588 if (r < 0)
589 return r;
590
591 r = unit_add_exec_dependencies(u, &m->exec_context);
592 if (r < 0)
593 return r;
594
595 r = unit_set_default_slice(u);
596 if (r < 0)
597 return r;
598
599 r = mount_add_default_dependencies(m);
600 if (r < 0)
601 return r;
602
603 return 0;
604 }
605
606 static int mount_load_root_mount(Unit *u) {
607 assert(u);
608
609 if (!unit_has_name(u, SPECIAL_ROOT_MOUNT))
610 return 0;
611
612 u->perpetual = true;
613 u->default_dependencies = false;
614
615 /* The stdio/kmsg bridge socket is on /, in order to avoid a dep loop, don't use kmsg logging for -.mount */
616 MOUNT(u)->exec_context.std_output = EXEC_OUTPUT_NULL;
617 MOUNT(u)->exec_context.std_input = EXEC_INPUT_NULL;
618
619 if (!u->description)
620 u->description = strdup("Root Mount");
621
622 return 1;
623 }
624
625 static int mount_load(Unit *u) {
626 Mount *m = MOUNT(u);
627 int r;
628
629 assert(u);
630 assert(u->load_state == UNIT_STUB);
631
632 r = mount_load_root_mount(u);
633 if (r < 0)
634 return r;
635
636 if (m->from_proc_self_mountinfo || u->perpetual)
637 r = unit_load_fragment_and_dropin_optional(u);
638 else
639 r = unit_load_fragment_and_dropin(u);
640 if (r < 0)
641 return r;
642
643 /* This is a new unit? Then let's add in some extras */
644 if (u->load_state == UNIT_LOADED) {
645 r = mount_add_extras(m);
646 if (r < 0)
647 return r;
648 }
649
650 return mount_verify(m);
651 }
652
653 static void mount_set_state(Mount *m, MountState state) {
654 MountState old_state;
655 assert(m);
656
657 old_state = m->state;
658 m->state = state;
659
660 if (!MOUNT_STATE_WITH_PROCESS(state)) {
661 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
662 mount_unwatch_control_pid(m);
663 m->control_command = NULL;
664 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
665 }
666
667 if (state != old_state)
668 log_unit_debug(UNIT(m), "Changed %s -> %s", mount_state_to_string(old_state), mount_state_to_string(state));
669
670 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
671 }
672
673 static int mount_coldplug(Unit *u) {
674 Mount *m = MOUNT(u);
675 MountState new_state = MOUNT_DEAD;
676 int r;
677
678 assert(m);
679 assert(m->state == MOUNT_DEAD);
680
681 if (m->deserialized_state != m->state)
682 new_state = m->deserialized_state;
683 else if (m->from_proc_self_mountinfo)
684 new_state = MOUNT_MOUNTED;
685
686 if (new_state == m->state)
687 return 0;
688
689 if (m->control_pid > 0 &&
690 pid_is_unwaited(m->control_pid) &&
691 MOUNT_STATE_WITH_PROCESS(new_state)) {
692
693 r = unit_watch_pid(UNIT(m), m->control_pid);
694 if (r < 0)
695 return r;
696
697 r = mount_arm_timer(m, usec_add(u->state_change_timestamp.monotonic, m->timeout_usec));
698 if (r < 0)
699 return r;
700 }
701
702 if (!IN_SET(new_state, MOUNT_DEAD, MOUNT_FAILED))
703 (void) unit_setup_dynamic_creds(u);
704
705 mount_set_state(m, new_state);
706 return 0;
707 }
708
709 static 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
756 static 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
802 static 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
823 static 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
832 static 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
845 static 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
861 static 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
896 fail:
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
901 static 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
934 fail:
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
939 static void mount_enter_mounting(Mount *m) {
940 int r;
941 MountParameters *p;
942
943 assert(m);
944
945 r = unit_fail_if_noncanonical(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
992 fail:
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
997 static 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
1007 static 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
1050 fail:
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
1056 static 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
1095 static 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
1134 static int mount_reload(Unit *u) {
1135 Mount *m = MOUNT(u);
1136
1137 assert(m);
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 due to the io event priority logic, we can be sure the new mountinfo is loaded
1280 * before we process the SIGCHLD for the mount command. */
1281
1282 switch (m->state) {
1283
1284 case MOUNT_MOUNTING:
1285 /* Our mount point has not appeared in mountinfo. Something went wrong. */
1286
1287 if (f == MOUNT_SUCCESS) {
1288 /* Either /bin/mount has an unexpected definition of success,
1289 * or someone raced us and we lost. */
1290 log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
1291 f = MOUNT_FAILURE_PROTOCOL;
1292 }
1293 mount_enter_dead(m, f);
1294 break;
1295
1296 case MOUNT_MOUNTING_DONE:
1297 mount_enter_mounted(m, f);
1298 break;
1299
1300 case MOUNT_REMOUNTING:
1301 case MOUNT_REMOUNTING_SIGTERM:
1302 case MOUNT_REMOUNTING_SIGKILL:
1303 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1304 break;
1305
1306 case MOUNT_UNMOUNTING:
1307
1308 if (f == MOUNT_SUCCESS && 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. We might exceed the timeout specified by the user overall,
1312 * but we will stop as soon as any one umount times out. */
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_warning(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_or_mounted(m, f);
1324
1325 break;
1326
1327 case MOUNT_UNMOUNTING_SIGKILL:
1328 case MOUNT_UNMOUNTING_SIGTERM:
1329 mount_enter_dead_or_mounted(m, f);
1330 break;
1331
1332 default:
1333 assert_not_reached("Uh, control process died at wrong time.");
1334 }
1335
1336 /* Notify clients about changed exit status */
1337 unit_add_to_dbus_queue(u);
1338 }
1339
1340 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1341 Mount *m = MOUNT(userdata);
1342
1343 assert(m);
1344 assert(m->timer_event_source == source);
1345
1346 switch (m->state) {
1347
1348 case MOUNT_MOUNTING:
1349 case MOUNT_MOUNTING_DONE:
1350 log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
1351 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1352 break;
1353
1354 case MOUNT_REMOUNTING:
1355 log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
1356 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1357 mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
1358 break;
1359
1360 case MOUNT_REMOUNTING_SIGTERM:
1361 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1362
1363 if (m->kill_context.send_sigkill) {
1364 log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
1365 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
1366 } else {
1367 log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1368 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1369 }
1370 break;
1371
1372 case MOUNT_REMOUNTING_SIGKILL:
1373 mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
1374
1375 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1376 mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
1377 break;
1378
1379 case MOUNT_UNMOUNTING:
1380 log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
1381 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1382 break;
1383
1384 case MOUNT_UNMOUNTING_SIGTERM:
1385 if (m->kill_context.send_sigkill) {
1386 log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
1387 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1388 } else {
1389 log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
1390 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1391 }
1392 break;
1393
1394 case MOUNT_UNMOUNTING_SIGKILL:
1395 log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
1396 mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
1397 break;
1398
1399 default:
1400 assert_not_reached("Timeout at wrong time.");
1401 }
1402
1403 return 0;
1404 }
1405
1406 typedef struct {
1407 bool is_mounted;
1408 bool just_mounted;
1409 bool just_changed;
1410 } MountSetupFlags;
1411
1412 static int mount_setup_new_unit(
1413 Unit *u,
1414 const char *what,
1415 const char *where,
1416 const char *options,
1417 const char *fstype,
1418 MountSetupFlags *flags) {
1419
1420 MountParameters *p;
1421
1422 assert(u);
1423 assert(flags);
1424
1425 u->source_path = strdup("/proc/self/mountinfo");
1426 MOUNT(u)->where = strdup(where);
1427 if (!u->source_path || !MOUNT(u)->where)
1428 return -ENOMEM;
1429
1430 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1431 MOUNT(u)->from_proc_self_mountinfo = true;
1432 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1433
1434 p->what = strdup(what);
1435 p->options = strdup(options);
1436 p->fstype = strdup(fstype);
1437 if (!p->what || !p->options || !p->fstype)
1438 return -ENOMEM;
1439
1440 if (!mount_is_extrinsic(MOUNT(u))) {
1441 const char *target;
1442 int r;
1443
1444 target = mount_is_network(p) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1445 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1446 if (r < 0)
1447 return r;
1448
1449 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1450 if (r < 0)
1451 return r;
1452 }
1453
1454 unit_add_to_load_queue(u);
1455 flags->is_mounted = true;
1456 flags->just_mounted = true;
1457 flags->just_changed = true;
1458
1459 return 0;
1460 }
1461
1462 static int mount_setup_existing_unit(
1463 Unit *u,
1464 const char *what,
1465 const char *where,
1466 const char *options,
1467 const char *fstype,
1468 MountSetupFlags *flags) {
1469
1470 MountParameters *p;
1471 bool load_extras = false;
1472 int r1, r2, r3;
1473
1474 assert(u);
1475 assert(flags);
1476
1477 if (!MOUNT(u)->where) {
1478 MOUNT(u)->where = strdup(where);
1479 if (!MOUNT(u)->where)
1480 return -ENOMEM;
1481 }
1482
1483 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1484 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1485
1486 r1 = free_and_strdup(&p->what, what);
1487 r2 = free_and_strdup(&p->options, options);
1488 r3 = free_and_strdup(&p->fstype, fstype);
1489 if (r1 < 0 || r2 < 0 || r3 < 0)
1490 return -ENOMEM;
1491
1492 flags->just_changed = r1 > 0 || r2 > 0 || r3 > 0;
1493 flags->is_mounted = true;
1494 flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
1495
1496 MOUNT(u)->from_proc_self_mountinfo = true;
1497
1498 if (!mount_is_extrinsic(MOUNT(u)) && mount_is_network(p)) {
1499 /* _netdev option may have shown up late, or on a
1500 * remount. Add remote-fs dependencies, even though
1501 * local-fs ones may already be there.
1502 *
1503 * Note: due to a current limitation (we don't track
1504 * in the dependency "Set*" objects who created a
1505 * dependency), we can only add deps, never lose them,
1506 * until the next full daemon-reload. */
1507 unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
1508 load_extras = true;
1509 }
1510
1511 if (u->load_state == UNIT_NOT_FOUND) {
1512 u->load_state = UNIT_LOADED;
1513 u->load_error = 0;
1514
1515 /* Load in the extras later on, after we
1516 * finished initialization of the unit */
1517
1518 /* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
1519 load_extras = true;
1520 flags->just_changed = true;
1521 }
1522
1523 if (load_extras)
1524 return mount_add_extras(MOUNT(u));
1525
1526 return 0;
1527 }
1528
1529 static int mount_setup_unit(
1530 Manager *m,
1531 const char *what,
1532 const char *where,
1533 const char *options,
1534 const char *fstype,
1535 bool set_flags) {
1536
1537 _cleanup_free_ char *e = NULL;
1538 MountSetupFlags flags;
1539 Unit *u;
1540 int r;
1541
1542 assert(m);
1543 assert(what);
1544 assert(where);
1545 assert(options);
1546 assert(fstype);
1547
1548 /* Ignore API mount points. They should never be referenced in
1549 * dependencies ever. */
1550 if (mount_point_is_api(where) || mount_point_ignore(where))
1551 return 0;
1552
1553 if (streq(fstype, "autofs"))
1554 return 0;
1555
1556 /* probably some kind of swap, ignore */
1557 if (!is_path(where))
1558 return 0;
1559
1560 r = unit_name_from_path(where, ".mount", &e);
1561 if (r < 0)
1562 return r;
1563
1564 u = manager_get_unit(m, e);
1565 if (!u) {
1566 /* First time we see this mount point meaning that it's
1567 * not been initiated by a mount unit but rather by the
1568 * sysadmin having called mount(8) directly. */
1569 r = unit_new_for_name(m, sizeof(Mount), e, &u);
1570 if (r < 0)
1571 goto fail;
1572
1573 r = mount_setup_new_unit(u, what, where, options, fstype, &flags);
1574 if (r < 0)
1575 unit_free(u);
1576 } else
1577 r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
1578
1579 if (r < 0)
1580 goto fail;
1581
1582 if (set_flags) {
1583 MOUNT(u)->is_mounted = flags.is_mounted;
1584 MOUNT(u)->just_mounted = flags.just_mounted;
1585 MOUNT(u)->just_changed = flags.just_changed;
1586 }
1587
1588 if (flags.just_changed)
1589 unit_add_to_dbus_queue(u);
1590
1591 return 0;
1592 fail:
1593 log_warning_errno(r, "Failed to set up mount unit: %m");
1594 return r;
1595 }
1596
1597 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1598 _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
1599 _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
1600 int r = 0;
1601
1602 assert(m);
1603
1604 t = mnt_new_table();
1605 if (!t)
1606 return log_oom();
1607
1608 i = mnt_new_iter(MNT_ITER_FORWARD);
1609 if (!i)
1610 return log_oom();
1611
1612 r = mnt_table_parse_mtab(t, NULL);
1613 if (r < 0)
1614 return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
1615
1616 r = 0;
1617 for (;;) {
1618 const char *device, *path, *options, *fstype;
1619 _cleanup_free_ char *d = NULL, *p = NULL;
1620 struct libmnt_fs *fs;
1621 int k;
1622
1623 k = mnt_table_next_fs(t, i, &fs);
1624 if (k == 1)
1625 break;
1626 if (k < 0)
1627 return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
1628
1629 device = mnt_fs_get_source(fs);
1630 path = mnt_fs_get_target(fs);
1631 options = mnt_fs_get_options(fs);
1632 fstype = mnt_fs_get_fstype(fs);
1633
1634 if (!device || !path)
1635 continue;
1636
1637 if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
1638 return log_oom();
1639
1640 if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
1641 return log_oom();
1642
1643 (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
1644
1645 k = mount_setup_unit(m, d, p, options, fstype, set_flags);
1646 if (r == 0 && k < 0)
1647 r = k;
1648 }
1649
1650 return r;
1651 }
1652
1653 static void mount_shutdown(Manager *m) {
1654 assert(m);
1655
1656 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1657
1658 mnt_unref_monitor(m->mount_monitor);
1659 m->mount_monitor = NULL;
1660 }
1661
1662 static int mount_get_timeout(Unit *u, usec_t *timeout) {
1663 Mount *m = MOUNT(u);
1664 usec_t t;
1665 int r;
1666
1667 if (!m->timer_event_source)
1668 return 0;
1669
1670 r = sd_event_source_get_time(m->timer_event_source, &t);
1671 if (r < 0)
1672 return r;
1673 if (t == USEC_INFINITY)
1674 return 0;
1675
1676 *timeout = t;
1677 return 1;
1678 }
1679
1680 static int synthesize_root_mount(Manager *m) {
1681 Unit *u;
1682 int r;
1683
1684 assert(m);
1685
1686 /* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
1687 * unconditionally synthesize it here and mark it as perpetual. */
1688
1689 u = manager_get_unit(m, SPECIAL_ROOT_MOUNT);
1690 if (!u) {
1691 r = unit_new_for_name(m, sizeof(Mount), SPECIAL_ROOT_MOUNT, &u);
1692 if (r < 0)
1693 return log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
1694 }
1695
1696 u->perpetual = true;
1697 MOUNT(u)->deserialized_state = MOUNT_MOUNTED;
1698
1699 unit_add_to_load_queue(u);
1700 unit_add_to_dbus_queue(u);
1701
1702 return 0;
1703 }
1704
1705 static bool mount_is_mounted(Mount *m) {
1706 assert(m);
1707
1708 return UNIT(m)->perpetual || m->is_mounted;
1709 }
1710
1711 static void mount_enumerate(Manager *m) {
1712 int r;
1713
1714 assert(m);
1715
1716 r = synthesize_root_mount(m);
1717 if (r < 0)
1718 goto fail;
1719
1720 mnt_init_debug(0);
1721
1722 if (!m->mount_monitor) {
1723 int fd;
1724
1725 m->mount_monitor = mnt_new_monitor();
1726 if (!m->mount_monitor) {
1727 log_oom();
1728 goto fail;
1729 }
1730
1731 r = mnt_monitor_enable_kernel(m->mount_monitor, 1);
1732 if (r < 0) {
1733 log_error_errno(r, "Failed to enable watching of kernel mount events: %m");
1734 goto fail;
1735 }
1736
1737 r = mnt_monitor_enable_userspace(m->mount_monitor, 1, NULL);
1738 if (r < 0) {
1739 log_error_errno(r, "Failed to enable watching of userspace mount events: %m");
1740 goto fail;
1741 }
1742
1743 /* mnt_unref_monitor() will close the fd */
1744 fd = r = mnt_monitor_get_fd(m->mount_monitor);
1745 if (r < 0) {
1746 log_error_errno(r, "Failed to acquire watch file descriptor: %m");
1747 goto fail;
1748 }
1749
1750 r = sd_event_add_io(m->event, &m->mount_event_source, fd, EPOLLIN, mount_dispatch_io, m);
1751 if (r < 0) {
1752 log_error_errno(r, "Failed to watch mount file descriptor: %m");
1753 goto fail;
1754 }
1755
1756 r = sd_event_source_set_priority(m->mount_event_source, -10);
1757 if (r < 0) {
1758 log_error_errno(r, "Failed to adjust mount watch priority: %m");
1759 goto fail;
1760 }
1761
1762 (void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
1763 }
1764
1765 r = mount_load_proc_self_mountinfo(m, false);
1766 if (r < 0)
1767 goto fail;
1768
1769 return;
1770
1771 fail:
1772 mount_shutdown(m);
1773 }
1774
1775 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1776 _cleanup_set_free_ Set *around = NULL, *gone = NULL;
1777 Manager *m = userdata;
1778 const char *what;
1779 Iterator i;
1780 Unit *u;
1781 int r;
1782
1783 assert(m);
1784 assert(revents & EPOLLIN);
1785
1786 if (fd == mnt_monitor_get_fd(m->mount_monitor)) {
1787 bool rescan = false;
1788
1789 /* Drain all events and verify that the event is valid.
1790 *
1791 * Note that libmount also monitors /run/mount mkdir if the
1792 * directory does not exist yet. The mkdir may generate event
1793 * which is irrelevant for us.
1794 *
1795 * error: r < 0; valid: r == 0, false positive: rc == 1 */
1796 do {
1797 r = mnt_monitor_next_change(m->mount_monitor, NULL, NULL);
1798 if (r == 0)
1799 rescan = true;
1800 else if (r < 0)
1801 return log_error_errno(r, "Failed to drain libmount events");
1802 } while (r == 0);
1803
1804 log_debug("libmount event [rescan: %s]", yes_no(rescan));
1805 if (!rescan)
1806 return 0;
1807 }
1808
1809 r = mount_load_proc_self_mountinfo(m, true);
1810 if (r < 0) {
1811 /* Reset flags, just in case, for later calls */
1812 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1813 Mount *mount = MOUNT(u);
1814
1815 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1816 }
1817
1818 return 0;
1819 }
1820
1821 manager_dispatch_load_queue(m);
1822
1823 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1824 Mount *mount = MOUNT(u);
1825
1826 if (!mount_is_mounted(mount)) {
1827
1828 /* A mount point is not around right now. It
1829 * might be gone, or might never have
1830 * existed. */
1831
1832 if (mount->from_proc_self_mountinfo &&
1833 mount->parameters_proc_self_mountinfo.what) {
1834
1835 /* Remember that this device might just have disappeared */
1836 if (set_ensure_allocated(&gone, &string_hash_ops) < 0 ||
1837 set_put(gone, mount->parameters_proc_self_mountinfo.what) < 0)
1838 log_oom(); /* we don't care too much about OOM here... */
1839 }
1840
1841 mount->from_proc_self_mountinfo = false;
1842
1843 switch (mount->state) {
1844
1845 case MOUNT_MOUNTED:
1846 /* This has just been unmounted by
1847 * somebody else, follow the state
1848 * change. */
1849 mount->result = MOUNT_SUCCESS; /* make sure we forget any earlier umount failures */
1850 mount_enter_dead(mount, MOUNT_SUCCESS);
1851 break;
1852
1853 default:
1854 break;
1855 }
1856
1857 } else if (mount->just_mounted || mount->just_changed) {
1858
1859 /* A mount point was added or changed */
1860
1861 switch (mount->state) {
1862
1863 case MOUNT_DEAD:
1864 case MOUNT_FAILED:
1865
1866 /* This has just been mounted by somebody else, follow the state change, but let's
1867 * generate a new invocation ID for this implicitly and automatically. */
1868 (void) unit_acquire_invocation_id(UNIT(mount));
1869 mount_enter_mounted(mount, MOUNT_SUCCESS);
1870 break;
1871
1872 case MOUNT_MOUNTING:
1873 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1874 break;
1875
1876 default:
1877 /* Nothing really changed, but let's
1878 * issue an notification call
1879 * nonetheless, in case somebody is
1880 * waiting for this. (e.g. file system
1881 * ro/rw remounts.) */
1882 mount_set_state(mount, mount->state);
1883 break;
1884 }
1885 }
1886
1887 if (mount_is_mounted(mount) &&
1888 mount->from_proc_self_mountinfo &&
1889 mount->parameters_proc_self_mountinfo.what) {
1890
1891 if (set_ensure_allocated(&around, &string_hash_ops) < 0 ||
1892 set_put(around, mount->parameters_proc_self_mountinfo.what) < 0)
1893 log_oom();
1894 }
1895
1896 /* Reset the flags for later calls */
1897 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1898 }
1899
1900 SET_FOREACH(what, gone, i) {
1901 if (set_contains(around, what))
1902 continue;
1903
1904 /* Let the device units know that the device is no longer mounted */
1905 (void) device_found_node(m, what, false, DEVICE_FOUND_MOUNT, true);
1906 }
1907
1908 return 0;
1909 }
1910
1911 static void mount_reset_failed(Unit *u) {
1912 Mount *m = MOUNT(u);
1913
1914 assert(m);
1915
1916 if (m->state == MOUNT_FAILED)
1917 mount_set_state(m, MOUNT_DEAD);
1918
1919 m->result = MOUNT_SUCCESS;
1920 m->reload_result = MOUNT_SUCCESS;
1921 }
1922
1923 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1924 Mount *m = MOUNT(u);
1925
1926 assert(m);
1927
1928 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1929 }
1930
1931 static int mount_control_pid(Unit *u) {
1932 Mount *m = MOUNT(u);
1933
1934 assert(m);
1935
1936 return m->control_pid;
1937 }
1938
1939 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1940 [MOUNT_EXEC_MOUNT] = "ExecMount",
1941 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1942 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1943 };
1944
1945 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1946
1947 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1948 [MOUNT_SUCCESS] = "success",
1949 [MOUNT_FAILURE_RESOURCES] = "resources",
1950 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1951 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1952 [MOUNT_FAILURE_SIGNAL] = "signal",
1953 [MOUNT_FAILURE_CORE_DUMP] = "core-dump",
1954 [MOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
1955 [MOUNT_FAILURE_PROTOCOL] = "protocol",
1956 };
1957
1958 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1959
1960 const UnitVTable mount_vtable = {
1961 .object_size = sizeof(Mount),
1962 .exec_context_offset = offsetof(Mount, exec_context),
1963 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1964 .kill_context_offset = offsetof(Mount, kill_context),
1965 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1966 .dynamic_creds_offset = offsetof(Mount, dynamic_creds),
1967
1968 .sections =
1969 "Unit\0"
1970 "Mount\0"
1971 "Install\0",
1972 .private_section = "Mount",
1973
1974 .init = mount_init,
1975 .load = mount_load,
1976 .done = mount_done,
1977
1978 .coldplug = mount_coldplug,
1979
1980 .dump = mount_dump,
1981
1982 .start = mount_start,
1983 .stop = mount_stop,
1984 .reload = mount_reload,
1985
1986 .kill = mount_kill,
1987
1988 .serialize = mount_serialize,
1989 .deserialize_item = mount_deserialize_item,
1990
1991 .active_state = mount_active_state,
1992 .sub_state_to_string = mount_sub_state_to_string,
1993
1994 .check_gc = mount_check_gc,
1995
1996 .sigchld_event = mount_sigchld_event,
1997
1998 .reset_failed = mount_reset_failed,
1999
2000 .control_pid = mount_control_pid,
2001
2002 .bus_vtable = bus_mount_vtable,
2003 .bus_set_property = bus_mount_set_property,
2004 .bus_commit_properties = bus_mount_commit_properties,
2005
2006 .get_timeout = mount_get_timeout,
2007
2008 .can_transient = true,
2009
2010 .enumerate = mount_enumerate,
2011 .shutdown = mount_shutdown,
2012
2013 .status_message_formats = {
2014 .starting_stopping = {
2015 [0] = "Mounting %s...",
2016 [1] = "Unmounting %s...",
2017 },
2018 .finished_start_job = {
2019 [JOB_DONE] = "Mounted %s.",
2020 [JOB_FAILED] = "Failed to mount %s.",
2021 [JOB_TIMEOUT] = "Timed out mounting %s.",
2022 },
2023 .finished_stop_job = {
2024 [JOB_DONE] = "Unmounted %s.",
2025 [JOB_FAILED] = "Failed unmounting %s.",
2026 [JOB_TIMEOUT] = "Timed out unmounting %s.",
2027 },
2028 },
2029 };
Unnamed repository; edit this file 'description' to name the repository.