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