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


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