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


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