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