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