]> 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
gpt-auto-generator: properly ignore value
[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.cgroup_delegate = m->cgroup_context.delegate;
719 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
720 exec_params.unit_id = UNIT(m)->id;
721
722 r = exec_spawn(c,
723 &m->exec_context,
724 &exec_params,
725 m->exec_runtime,
726 &pid);
727 if (r < 0)
728 goto fail;
729
730 r = unit_watch_pid(UNIT(m), pid);
731 if (r < 0)
732 /* FIXME: we need to do something here */
733 goto fail;
734
735 *_pid = pid;
736
737 return 0;
738
739 fail:
740 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
741
742 return r;
743 }
744
745 static void mount_enter_dead(Mount *m, MountResult f) {
746 assert(m);
747
748 if (f != MOUNT_SUCCESS)
749 m->result = f;
750
751 exec_runtime_destroy(m->exec_runtime);
752 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
753
754 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
755
756 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
757 }
758
759 static void mount_enter_mounted(Mount *m, MountResult f) {
760 assert(m);
761
762 if (f != MOUNT_SUCCESS)
763 m->result = f;
764
765 mount_set_state(m, MOUNT_MOUNTED);
766 }
767
768 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
769 int r;
770
771 assert(m);
772
773 if (f != MOUNT_SUCCESS)
774 m->result = f;
775
776 r = unit_kill_context(
777 UNIT(m),
778 &m->kill_context,
779 (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
780 KILL_KILL : KILL_TERMINATE,
781 -1,
782 m->control_pid,
783 false);
784 if (r < 0)
785 goto fail;
786
787 if (r > 0) {
788 r = mount_arm_timer(m);
789 if (r < 0)
790 goto fail;
791
792 mount_set_state(m, state);
793 } else if (state == MOUNT_REMOUNTING_SIGTERM)
794 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
795 else if (state == MOUNT_REMOUNTING_SIGKILL)
796 mount_enter_mounted(m, MOUNT_SUCCESS);
797 else if (state == MOUNT_MOUNTING_SIGTERM)
798 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
799 else if (state == MOUNT_UNMOUNTING_SIGTERM)
800 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
801 else
802 mount_enter_dead(m, MOUNT_SUCCESS);
803
804 return;
805
806 fail:
807 log_warning_unit(UNIT(m)->id,
808 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
809
810 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
811 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
812 else
813 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
814 }
815
816 void warn_if_dir_nonempty(const char *unit, const char* where) {
817 int r;
818
819 assert(unit);
820 assert(where);
821
822 r = dir_is_empty(where);
823 if (r > 0)
824 return;
825 else if (r == 0)
826 log_struct_unit(LOG_NOTICE,
827 unit,
828 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
829 unit, where,
830 "WHERE=%s", where,
831 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
832 NULL);
833 else
834 log_warning_unit(unit,
835 "MESSAGE=Failed to check directory %s: %s",
836 where, strerror(-r));
837 }
838
839 static int fail_if_symlink(const char *unit, const char* where) {
840 assert(where);
841
842 if (is_symlink(where) > 0) {
843 log_struct_unit(LOG_WARNING,
844 unit,
845 "MESSAGE=%s: Mount on symlink %s not allowed.",
846 unit, where,
847 "WHERE=%s", where,
848 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
849 NULL);
850
851 return -ELOOP;
852 }
853 return 0;
854 }
855
856 static void mount_enter_unmounting(Mount *m) {
857 int r;
858
859 assert(m);
860
861 m->control_command_id = MOUNT_EXEC_UNMOUNT;
862 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
863
864 if ((r = exec_command_set(
865 m->control_command,
866 "/bin/umount",
867 "-n",
868 m->where,
869 NULL)) < 0)
870 goto fail;
871
872 mount_unwatch_control_pid(m);
873
874 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
875 goto fail;
876
877 mount_set_state(m, MOUNT_UNMOUNTING);
878
879 return;
880
881 fail:
882 log_warning_unit(UNIT(m)->id,
883 "%s failed to run 'umount' task: %s",
884 UNIT(m)->id, strerror(-r));
885 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
886 }
887
888 static void mount_enter_mounting(Mount *m) {
889 int r;
890 MountParameters *p;
891
892 assert(m);
893
894 m->control_command_id = MOUNT_EXEC_MOUNT;
895 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
896
897 mkdir_p_label(m->where, m->directory_mode);
898
899 warn_if_dir_nonempty(m->meta.id, m->where);
900
901 /* Create the source directory for bind-mounts if needed */
902 p = get_mount_parameters_fragment(m);
903 if (p && mount_is_bind(p))
904 mkdir_p_label(p->what, m->directory_mode);
905
906 r = fail_if_symlink(m->meta.id, m->where);
907 if (r < 0)
908 goto fail;
909
910 if (m->from_fragment)
911 r = exec_command_set(
912 m->control_command,
913 "/bin/mount",
914 m->sloppy_options ? "-ns" : "-n",
915 m->parameters_fragment.what,
916 m->where,
917 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
918 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
919 NULL);
920 else
921 r = -ENOENT;
922
923 if (r < 0)
924 goto fail;
925
926 mount_unwatch_control_pid(m);
927
928 r = mount_spawn(m, m->control_command, &m->control_pid);
929 if (r < 0)
930 goto fail;
931
932 mount_set_state(m, MOUNT_MOUNTING);
933
934 return;
935
936 fail:
937 log_warning_unit(UNIT(m)->id,
938 "%s failed to run 'mount' task: %s",
939 UNIT(m)->id, strerror(-r));
940 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
941 }
942
943 static void mount_enter_remounting(Mount *m) {
944 int r;
945
946 assert(m);
947
948 m->control_command_id = MOUNT_EXEC_REMOUNT;
949 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
950
951 if (m->from_fragment) {
952 const char *o;
953
954 if (m->parameters_fragment.options)
955 o = strappenda("remount,", m->parameters_fragment.options);
956 else
957 o = "remount";
958
959 r = exec_command_set(
960 m->control_command,
961 "/bin/mount",
962 m->sloppy_options ? "-ns" : "-n",
963 m->parameters_fragment.what,
964 m->where,
965 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
966 "-o", o,
967 NULL);
968 } else
969 r = -ENOENT;
970
971 if (r < 0)
972 goto fail;
973
974 mount_unwatch_control_pid(m);
975
976 r = mount_spawn(m, m->control_command, &m->control_pid);
977 if (r < 0)
978 goto fail;
979
980 mount_set_state(m, MOUNT_REMOUNTING);
981
982 return;
983
984 fail:
985 log_warning_unit(UNIT(m)->id,
986 "%s failed to run 'remount' task: %s",
987 UNIT(m)->id, strerror(-r));
988 m->reload_result = MOUNT_FAILURE_RESOURCES;
989 mount_enter_mounted(m, MOUNT_SUCCESS);
990 }
991
992 static int mount_start(Unit *u) {
993 Mount *m = MOUNT(u);
994
995 assert(m);
996
997 /* We cannot fulfill this request right now, try again later
998 * please! */
999 if (m->state == MOUNT_UNMOUNTING ||
1000 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1001 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1002 m->state == MOUNT_MOUNTING_SIGTERM ||
1003 m->state == MOUNT_MOUNTING_SIGKILL)
1004 return -EAGAIN;
1005
1006 /* Already on it! */
1007 if (m->state == MOUNT_MOUNTING)
1008 return 0;
1009
1010 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1011
1012 m->result = MOUNT_SUCCESS;
1013 m->reload_result = MOUNT_SUCCESS;
1014
1015 mount_enter_mounting(m);
1016 return 0;
1017 }
1018
1019 static int mount_stop(Unit *u) {
1020 Mount *m = MOUNT(u);
1021
1022 assert(m);
1023
1024 /* Already on it */
1025 if (m->state == MOUNT_UNMOUNTING ||
1026 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1027 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1028 m->state == MOUNT_MOUNTING_SIGTERM ||
1029 m->state == MOUNT_MOUNTING_SIGKILL)
1030 return 0;
1031
1032 assert(m->state == MOUNT_MOUNTING ||
1033 m->state == MOUNT_MOUNTING_DONE ||
1034 m->state == MOUNT_MOUNTED ||
1035 m->state == MOUNT_REMOUNTING ||
1036 m->state == MOUNT_REMOUNTING_SIGTERM ||
1037 m->state == MOUNT_REMOUNTING_SIGKILL);
1038
1039 mount_enter_unmounting(m);
1040 return 0;
1041 }
1042
1043 static int mount_reload(Unit *u) {
1044 Mount *m = MOUNT(u);
1045
1046 assert(m);
1047
1048 if (m->state == MOUNT_MOUNTING_DONE)
1049 return -EAGAIN;
1050
1051 assert(m->state == MOUNT_MOUNTED);
1052
1053 mount_enter_remounting(m);
1054 return 0;
1055 }
1056
1057 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1058 Mount *m = MOUNT(u);
1059
1060 assert(m);
1061 assert(f);
1062 assert(fds);
1063
1064 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1065 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1066 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1067
1068 if (m->control_pid > 0)
1069 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1070
1071 if (m->control_command_id >= 0)
1072 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1073
1074 return 0;
1075 }
1076
1077 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1078 Mount *m = MOUNT(u);
1079
1080 assert(u);
1081 assert(key);
1082 assert(value);
1083 assert(fds);
1084
1085 if (streq(key, "state")) {
1086 MountState state;
1087
1088 if ((state = mount_state_from_string(value)) < 0)
1089 log_debug_unit(u->id, "Failed to parse state value %s", value);
1090 else
1091 m->deserialized_state = state;
1092 } else if (streq(key, "result")) {
1093 MountResult f;
1094
1095 f = mount_result_from_string(value);
1096 if (f < 0)
1097 log_debug_unit(UNIT(m)->id,
1098 "Failed to parse result value %s", value);
1099 else if (f != MOUNT_SUCCESS)
1100 m->result = f;
1101
1102 } else if (streq(key, "reload-result")) {
1103 MountResult f;
1104
1105 f = mount_result_from_string(value);
1106 if (f < 0)
1107 log_debug_unit(UNIT(m)->id,
1108 "Failed to parse reload result value %s", value);
1109 else if (f != MOUNT_SUCCESS)
1110 m->reload_result = f;
1111
1112 } else if (streq(key, "control-pid")) {
1113 pid_t pid;
1114
1115 if (parse_pid(value, &pid) < 0)
1116 log_debug_unit(UNIT(m)->id,
1117 "Failed to parse control-pid value %s", value);
1118 else
1119 m->control_pid = pid;
1120 } else if (streq(key, "control-command")) {
1121 MountExecCommand id;
1122
1123 if ((id = mount_exec_command_from_string(value)) < 0)
1124 log_debug_unit(UNIT(m)->id,
1125 "Failed to parse exec-command value %s", value);
1126 else {
1127 m->control_command_id = id;
1128 m->control_command = m->exec_command + id;
1129 }
1130 } else
1131 log_debug_unit(UNIT(m)->id,
1132 "Unknown serialization key '%s'", key);
1133
1134 return 0;
1135 }
1136
1137 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1138 assert(u);
1139
1140 return state_translation_table[MOUNT(u)->state];
1141 }
1142
1143 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1144 assert(u);
1145
1146 return mount_state_to_string(MOUNT(u)->state);
1147 }
1148
1149 _pure_ static bool mount_check_gc(Unit *u) {
1150 Mount *m = MOUNT(u);
1151
1152 assert(m);
1153
1154 return m->from_proc_self_mountinfo;
1155 }
1156
1157 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1158 Mount *m = MOUNT(u);
1159 MountResult f;
1160
1161 assert(m);
1162 assert(pid >= 0);
1163
1164 if (pid != m->control_pid)
1165 return;
1166
1167 m->control_pid = 0;
1168
1169 if (is_clean_exit(code, status, NULL))
1170 f = MOUNT_SUCCESS;
1171 else if (code == CLD_EXITED)
1172 f = MOUNT_FAILURE_EXIT_CODE;
1173 else if (code == CLD_KILLED)
1174 f = MOUNT_FAILURE_SIGNAL;
1175 else if (code == CLD_DUMPED)
1176 f = MOUNT_FAILURE_CORE_DUMP;
1177 else
1178 assert_not_reached("Unknown code");
1179
1180 if (f != MOUNT_SUCCESS)
1181 m->result = f;
1182
1183 if (m->control_command) {
1184 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1185
1186 m->control_command = NULL;
1187 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1188 }
1189
1190 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1191 "%s mount process exited, code=%s status=%i",
1192 u->id, sigchld_code_to_string(code), status);
1193
1194 /* Note that mount(8) returning and the kernel sending us a
1195 * mount table change event might happen out-of-order. If an
1196 * operation succeed we assume the kernel will follow soon too
1197 * and already change into the resulting state. If it fails
1198 * we check if the kernel still knows about the mount. and
1199 * change state accordingly. */
1200
1201 switch (m->state) {
1202
1203 case MOUNT_MOUNTING:
1204 case MOUNT_MOUNTING_DONE:
1205 case MOUNT_MOUNTING_SIGKILL:
1206 case MOUNT_MOUNTING_SIGTERM:
1207
1208 if (f == MOUNT_SUCCESS)
1209 mount_enter_mounted(m, f);
1210 else if (m->from_proc_self_mountinfo)
1211 mount_enter_mounted(m, f);
1212 else
1213 mount_enter_dead(m, f);
1214 break;
1215
1216 case MOUNT_REMOUNTING:
1217 case MOUNT_REMOUNTING_SIGKILL:
1218 case MOUNT_REMOUNTING_SIGTERM:
1219
1220 m->reload_result = f;
1221 if (m->from_proc_self_mountinfo)
1222 mount_enter_mounted(m, MOUNT_SUCCESS);
1223 else
1224 mount_enter_dead(m, MOUNT_SUCCESS);
1225
1226 break;
1227
1228 case MOUNT_UNMOUNTING:
1229 case MOUNT_UNMOUNTING_SIGKILL:
1230 case MOUNT_UNMOUNTING_SIGTERM:
1231
1232 if (f == MOUNT_SUCCESS)
1233 mount_enter_dead(m, f);
1234 else if (m->from_proc_self_mountinfo)
1235 mount_enter_mounted(m, f);
1236 else
1237 mount_enter_dead(m, f);
1238 break;
1239
1240 default:
1241 assert_not_reached("Uh, control process died at wrong time.");
1242 }
1243
1244 /* Notify clients about changed exit status */
1245 unit_add_to_dbus_queue(u);
1246 }
1247
1248 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1249 Mount *m = MOUNT(userdata);
1250
1251 assert(m);
1252 assert(m->timer_event_source == source);
1253
1254 switch (m->state) {
1255
1256 case MOUNT_MOUNTING:
1257 case MOUNT_MOUNTING_DONE:
1258 log_warning_unit(UNIT(m)->id,
1259 "%s mounting timed out. Stopping.", UNIT(m)->id);
1260 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1261 break;
1262
1263 case MOUNT_REMOUNTING:
1264 log_warning_unit(UNIT(m)->id,
1265 "%s remounting timed out. Stopping.", UNIT(m)->id);
1266 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1267 mount_enter_mounted(m, MOUNT_SUCCESS);
1268 break;
1269
1270 case MOUNT_UNMOUNTING:
1271 log_warning_unit(UNIT(m)->id,
1272 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1273 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1274 break;
1275
1276 case MOUNT_MOUNTING_SIGTERM:
1277 if (m->kill_context.send_sigkill) {
1278 log_warning_unit(UNIT(m)->id,
1279 "%s mounting timed out. Killing.", UNIT(m)->id);
1280 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1281 } else {
1282 log_warning_unit(UNIT(m)->id,
1283 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1284 UNIT(m)->id);
1285
1286 if (m->from_proc_self_mountinfo)
1287 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1288 else
1289 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1290 }
1291 break;
1292
1293 case MOUNT_REMOUNTING_SIGTERM:
1294 if (m->kill_context.send_sigkill) {
1295 log_warning_unit(UNIT(m)->id,
1296 "%s remounting timed out. Killing.", UNIT(m)->id);
1297 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1298 } else {
1299 log_warning_unit(UNIT(m)->id,
1300 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1301 UNIT(m)->id);
1302
1303 if (m->from_proc_self_mountinfo)
1304 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1305 else
1306 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1307 }
1308 break;
1309
1310 case MOUNT_UNMOUNTING_SIGTERM:
1311 if (m->kill_context.send_sigkill) {
1312 log_warning_unit(UNIT(m)->id,
1313 "%s unmounting timed out. Killing.", UNIT(m)->id);
1314 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1315 } else {
1316 log_warning_unit(UNIT(m)->id,
1317 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1318 UNIT(m)->id);
1319
1320 if (m->from_proc_self_mountinfo)
1321 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1322 else
1323 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1324 }
1325 break;
1326
1327 case MOUNT_MOUNTING_SIGKILL:
1328 case MOUNT_REMOUNTING_SIGKILL:
1329 case MOUNT_UNMOUNTING_SIGKILL:
1330 log_warning_unit(UNIT(m)->id,
1331 "%s mount process still around after SIGKILL. Ignoring.",
1332 UNIT(m)->id);
1333
1334 if (m->from_proc_self_mountinfo)
1335 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1336 else
1337 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1338 break;
1339
1340 default:
1341 assert_not_reached("Timeout at wrong time.");
1342 }
1343
1344 return 0;
1345 }
1346
1347 static int mount_add_one(
1348 Manager *m,
1349 const char *what,
1350 const char *where,
1351 const char *options,
1352 const char *fstype,
1353 bool set_flags) {
1354
1355 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1356 bool load_extras = false;
1357 MountParameters *p;
1358 bool delete, changed = false;
1359 Unit *u;
1360 int r;
1361
1362 assert(m);
1363 assert(what);
1364 assert(where);
1365 assert(options);
1366 assert(fstype);
1367
1368 /* Ignore API mount points. They should never be referenced in
1369 * dependencies ever. */
1370 if (mount_point_is_api(where) || mount_point_ignore(where))
1371 return 0;
1372
1373 if (streq(fstype, "autofs"))
1374 return 0;
1375
1376 /* probably some kind of swap, ignore */
1377 if (!is_path(where))
1378 return 0;
1379
1380 e = unit_name_from_path(where, ".mount");
1381 if (!e)
1382 return -ENOMEM;
1383
1384 u = manager_get_unit(m, e);
1385 if (!u) {
1386 delete = true;
1387
1388 u = unit_new(m, sizeof(Mount));
1389 if (!u)
1390 return -ENOMEM;
1391
1392 r = unit_add_name(u, e);
1393 if (r < 0)
1394 goto fail;
1395
1396 MOUNT(u)->where = strdup(where);
1397 if (!MOUNT(u)->where) {
1398 r = -ENOMEM;
1399 goto fail;
1400 }
1401
1402 u->source_path = strdup("/proc/self/mountinfo");
1403 if (!u->source_path) {
1404 r = -ENOMEM;
1405 goto fail;
1406 }
1407
1408
1409 if (m->running_as == SYSTEMD_SYSTEM) {
1410 const char* target;
1411
1412 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1413
1414 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1415 if (r < 0)
1416 goto fail;
1417
1418 if (should_umount(MOUNT(u))) {
1419 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1420 if (r < 0)
1421 goto fail;
1422 }
1423 }
1424
1425 unit_add_to_load_queue(u);
1426 changed = true;
1427 } else {
1428 delete = false;
1429
1430 if (!MOUNT(u)->where) {
1431 MOUNT(u)->where = strdup(where);
1432 if (!MOUNT(u)->where) {
1433 r = -ENOMEM;
1434 goto fail;
1435 }
1436 }
1437
1438 if (u->load_state == UNIT_NOT_FOUND) {
1439 u->load_state = UNIT_LOADED;
1440 u->load_error = 0;
1441
1442 /* Load in the extras later on, after we
1443 * finished initialization of the unit */
1444 load_extras = true;
1445 changed = true;
1446 }
1447 }
1448
1449 w = strdup(what);
1450 o = strdup(options);
1451 f = strdup(fstype);
1452 if (!w || !o || !f) {
1453 r = -ENOMEM;
1454 goto fail;
1455 }
1456
1457 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1458
1459 changed = changed ||
1460 !streq_ptr(p->options, options) ||
1461 !streq_ptr(p->what, what) ||
1462 !streq_ptr(p->fstype, fstype);
1463
1464 if (set_flags) {
1465 MOUNT(u)->is_mounted = true;
1466 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1467 MOUNT(u)->just_changed = changed;
1468 }
1469
1470 MOUNT(u)->from_proc_self_mountinfo = true;
1471
1472 free(p->what);
1473 p->what = w;
1474 w = NULL;
1475
1476 free(p->options);
1477 p->options = o;
1478 o = NULL;
1479
1480 free(p->fstype);
1481 p->fstype = f;
1482 f = NULL;
1483
1484 if (load_extras) {
1485 r = mount_add_extras(MOUNT(u));
1486 if (r < 0)
1487 goto fail;
1488 }
1489
1490 if (changed)
1491 unit_add_to_dbus_queue(u);
1492
1493 return 0;
1494
1495 fail:
1496 if (delete && u)
1497 unit_free(u);
1498
1499 return r;
1500 }
1501
1502 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1503 int r = 0;
1504 unsigned i;
1505
1506 assert(m);
1507
1508 rewind(m->proc_self_mountinfo);
1509
1510 for (i = 1;; i++) {
1511 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1512 int k;
1513
1514 k = fscanf(m->proc_self_mountinfo,
1515 "%*s " /* (1) mount id */
1516 "%*s " /* (2) parent id */
1517 "%*s " /* (3) major:minor */
1518 "%*s " /* (4) root */
1519 "%ms " /* (5) mount point */
1520 "%ms" /* (6) mount options */
1521 "%*[^-]" /* (7) optional fields */
1522 "- " /* (8) separator */
1523 "%ms " /* (9) file system type */
1524 "%ms" /* (10) mount source */
1525 "%ms" /* (11) mount options 2 */
1526 "%*[^\n]", /* some rubbish at the end */
1527 &path,
1528 &options,
1529 &fstype,
1530 &device,
1531 &options2);
1532
1533 if (k == EOF)
1534 break;
1535
1536 if (k != 5) {
1537 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1538 continue;
1539 }
1540
1541 o = strjoin(options, ",", options2, NULL);
1542 if (!o)
1543 return log_oom();
1544
1545 d = cunescape(device);
1546 p = cunescape(path);
1547 if (!d || !p)
1548 return log_oom();
1549
1550 k = mount_add_one(m, d, p, o, fstype, set_flags);
1551 if (k < 0)
1552 r = k;
1553 }
1554
1555 return r;
1556 }
1557
1558 static void mount_shutdown(Manager *m) {
1559 assert(m);
1560
1561 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1562
1563 if (m->proc_self_mountinfo) {
1564 fclose(m->proc_self_mountinfo);
1565 m->proc_self_mountinfo = NULL;
1566 }
1567 }
1568
1569 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1570 Mount *m = MOUNT(u);
1571 int r;
1572
1573 if (!m->timer_event_source)
1574 return 0;
1575
1576 r = sd_event_source_get_time(m->timer_event_source, timeout);
1577 if (r < 0)
1578 return r;
1579
1580 return 1;
1581 }
1582
1583 static int mount_enumerate(Manager *m) {
1584 int r;
1585 assert(m);
1586
1587 if (!m->proc_self_mountinfo) {
1588 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1589 if (!m->proc_self_mountinfo)
1590 return -errno;
1591
1592 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1593 if (r < 0)
1594 goto fail;
1595
1596 /* Dispatch this before we dispatch SIGCHLD, so that
1597 * we always get the events from /proc/self/mountinfo
1598 * before the SIGCHLD of /bin/mount. */
1599 r = sd_event_source_set_priority(m->mount_event_source, -10);
1600 if (r < 0)
1601 goto fail;
1602 }
1603
1604 r = mount_load_proc_self_mountinfo(m, false);
1605 if (r < 0)
1606 goto fail;
1607
1608 return 0;
1609
1610 fail:
1611 mount_shutdown(m);
1612 return r;
1613 }
1614
1615 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1616 Manager *m = userdata;
1617 Unit *u;
1618 int r;
1619
1620 assert(m);
1621 assert(revents & EPOLLPRI);
1622
1623 /* The manager calls this for every fd event happening on the
1624 * /proc/self/mountinfo file, which informs us about mounting
1625 * table changes */
1626
1627 r = mount_load_proc_self_mountinfo(m, true);
1628 if (r < 0) {
1629 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1630
1631 /* Reset flags, just in case, for later calls */
1632 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1633 Mount *mount = MOUNT(u);
1634
1635 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1636 }
1637
1638 return 0;
1639 }
1640
1641 manager_dispatch_load_queue(m);
1642
1643 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1644 Mount *mount = MOUNT(u);
1645
1646 if (!mount->is_mounted) {
1647
1648 mount->from_proc_self_mountinfo = false;
1649
1650 switch (mount->state) {
1651
1652 case MOUNT_MOUNTED:
1653 /* This has just been unmounted by
1654 * somebody else, follow the state
1655 * change. */
1656 mount_enter_dead(mount, MOUNT_SUCCESS);
1657 break;
1658
1659 default:
1660 break;
1661 }
1662
1663 } else if (mount->just_mounted || mount->just_changed) {
1664
1665 /* New or changed mount entry */
1666
1667 switch (mount->state) {
1668
1669 case MOUNT_DEAD:
1670 case MOUNT_FAILED:
1671 /* This has just been mounted by
1672 * somebody else, follow the state
1673 * change. */
1674 mount_enter_mounted(mount, MOUNT_SUCCESS);
1675 break;
1676
1677 case MOUNT_MOUNTING:
1678 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1679 break;
1680
1681 default:
1682 /* Nothing really changed, but let's
1683 * issue an notification call
1684 * nonetheless, in case somebody is
1685 * waiting for this. (e.g. file system
1686 * ro/rw remounts.) */
1687 mount_set_state(mount, mount->state);
1688 break;
1689 }
1690 }
1691
1692 /* Reset the flags for later calls */
1693 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1694 }
1695
1696 return 0;
1697 }
1698
1699 static void mount_reset_failed(Unit *u) {
1700 Mount *m = MOUNT(u);
1701
1702 assert(m);
1703
1704 if (m->state == MOUNT_FAILED)
1705 mount_set_state(m, MOUNT_DEAD);
1706
1707 m->result = MOUNT_SUCCESS;
1708 m->reload_result = MOUNT_SUCCESS;
1709 }
1710
1711 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1712 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1713 }
1714
1715 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1716 [MOUNT_DEAD] = "dead",
1717 [MOUNT_MOUNTING] = "mounting",
1718 [MOUNT_MOUNTING_DONE] = "mounting-done",
1719 [MOUNT_MOUNTED] = "mounted",
1720 [MOUNT_REMOUNTING] = "remounting",
1721 [MOUNT_UNMOUNTING] = "unmounting",
1722 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1723 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1724 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1725 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1726 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1727 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1728 [MOUNT_FAILED] = "failed"
1729 };
1730
1731 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1732
1733 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1734 [MOUNT_EXEC_MOUNT] = "ExecMount",
1735 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1736 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1737 };
1738
1739 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1740
1741 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1742 [MOUNT_SUCCESS] = "success",
1743 [MOUNT_FAILURE_RESOURCES] = "resources",
1744 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1745 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1746 [MOUNT_FAILURE_SIGNAL] = "signal",
1747 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1748 };
1749
1750 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1751
1752 const UnitVTable mount_vtable = {
1753 .object_size = sizeof(Mount),
1754 .exec_context_offset = offsetof(Mount, exec_context),
1755 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1756 .kill_context_offset = offsetof(Mount, kill_context),
1757 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1758
1759 .sections =
1760 "Unit\0"
1761 "Mount\0"
1762 "Install\0",
1763 .private_section = "Mount",
1764
1765 .no_alias = true,
1766 .no_instances = true,
1767
1768 .init = mount_init,
1769 .load = mount_load,
1770 .done = mount_done,
1771
1772 .coldplug = mount_coldplug,
1773
1774 .dump = mount_dump,
1775
1776 .start = mount_start,
1777 .stop = mount_stop,
1778 .reload = mount_reload,
1779
1780 .kill = mount_kill,
1781
1782 .serialize = mount_serialize,
1783 .deserialize_item = mount_deserialize_item,
1784
1785 .active_state = mount_active_state,
1786 .sub_state_to_string = mount_sub_state_to_string,
1787
1788 .check_gc = mount_check_gc,
1789
1790 .sigchld_event = mount_sigchld_event,
1791
1792 .reset_failed = mount_reset_failed,
1793
1794 .bus_interface = "org.freedesktop.systemd1.Mount",
1795 .bus_vtable = bus_mount_vtable,
1796 .bus_set_property = bus_mount_set_property,
1797 .bus_commit_properties = bus_mount_commit_properties,
1798
1799 .get_timeout = mount_get_timeout,
1800
1801 .can_transient = true,
1802
1803 .enumerate = mount_enumerate,
1804 .shutdown = mount_shutdown,
1805
1806 .status_message_formats = {
1807 .starting_stopping = {
1808 [0] = "Mounting %s...",
1809 [1] = "Unmounting %s...",
1810 },
1811 .finished_start_job = {
1812 [JOB_DONE] = "Mounted %s.",
1813 [JOB_FAILED] = "Failed to mount %s.",
1814 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1815 [JOB_TIMEOUT] = "Timed out mounting %s.",
1816 },
1817 .finished_stop_job = {
1818 [JOB_DONE] = "Unmounted %s.",
1819 [JOB_FAILED] = "Failed unmounting %s.",
1820 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1821 },
1822 },
1823 };
Unnamed repository; edit this file 'description' to name the repository.