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


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