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