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