]> 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
treewide: no need to negate errno for log_*_errno()
[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_unit_error(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_unit_error(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_unit_error(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_unit_error(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_unit_debug(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_unit_warning(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_unit_struct(unit,
827 LOG_NOTICE,
828 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
829 LOG_MESSAGE("%s: Directory %s to mount over is not empty, mounting anyway.",
830 unit, where),
831 "WHERE=%s", where,
832 NULL);
833 else
834 log_unit_warning(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_unit_struct(unit,
844 LOG_ERR,
845 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
846 LOG_MESSAGE("%s: Mount on symlink %s not allowed.",
847 unit, where),
848 "WHERE=%s", where,
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_unit_warning(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_unit_warning(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_unit_warning(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_full(u->id,
1191 f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1192 "%s mount process exited, code=%s status=%i",
1193 u->id, sigchld_code_to_string(code), status);
1194
1195 /* Note that mount(8) returning and the kernel sending us a
1196 * mount table change event might happen out-of-order. If an
1197 * operation succeed we assume the kernel will follow soon too
1198 * and already change into the resulting state. If it fails
1199 * we check if the kernel still knows about the mount. and
1200 * change state accordingly. */
1201
1202 switch (m->state) {
1203
1204 case MOUNT_MOUNTING:
1205 case MOUNT_MOUNTING_DONE:
1206 case MOUNT_MOUNTING_SIGKILL:
1207 case MOUNT_MOUNTING_SIGTERM:
1208
1209 if (f == MOUNT_SUCCESS)
1210 mount_enter_mounted(m, f);
1211 else if (m->from_proc_self_mountinfo)
1212 mount_enter_mounted(m, f);
1213 else
1214 mount_enter_dead(m, f);
1215 break;
1216
1217 case MOUNT_REMOUNTING:
1218 case MOUNT_REMOUNTING_SIGKILL:
1219 case MOUNT_REMOUNTING_SIGTERM:
1220
1221 m->reload_result = f;
1222 if (m->from_proc_self_mountinfo)
1223 mount_enter_mounted(m, MOUNT_SUCCESS);
1224 else
1225 mount_enter_dead(m, MOUNT_SUCCESS);
1226
1227 break;
1228
1229 case MOUNT_UNMOUNTING:
1230 case MOUNT_UNMOUNTING_SIGKILL:
1231 case MOUNT_UNMOUNTING_SIGTERM:
1232
1233 if (f == MOUNT_SUCCESS)
1234 mount_enter_dead(m, f);
1235 else if (m->from_proc_self_mountinfo)
1236 mount_enter_mounted(m, f);
1237 else
1238 mount_enter_dead(m, f);
1239 break;
1240
1241 default:
1242 assert_not_reached("Uh, control process died at wrong time.");
1243 }
1244
1245 /* Notify clients about changed exit status */
1246 unit_add_to_dbus_queue(u);
1247 }
1248
1249 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1250 Mount *m = MOUNT(userdata);
1251
1252 assert(m);
1253 assert(m->timer_event_source == source);
1254
1255 switch (m->state) {
1256
1257 case MOUNT_MOUNTING:
1258 case MOUNT_MOUNTING_DONE:
1259 log_unit_warning(UNIT(m)->id,
1260 "%s mounting timed out. Stopping.", UNIT(m)->id);
1261 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1262 break;
1263
1264 case MOUNT_REMOUNTING:
1265 log_unit_warning(UNIT(m)->id,
1266 "%s remounting timed out. Stopping.", UNIT(m)->id);
1267 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1268 mount_enter_mounted(m, MOUNT_SUCCESS);
1269 break;
1270
1271 case MOUNT_UNMOUNTING:
1272 log_unit_warning(UNIT(m)->id,
1273 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1274 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1275 break;
1276
1277 case MOUNT_MOUNTING_SIGTERM:
1278 if (m->kill_context.send_sigkill) {
1279 log_unit_warning(UNIT(m)->id,
1280 "%s mounting timed out. Killing.", UNIT(m)->id);
1281 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1282 } else {
1283 log_unit_warning(UNIT(m)->id,
1284 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1285 UNIT(m)->id);
1286
1287 if (m->from_proc_self_mountinfo)
1288 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1289 else
1290 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1291 }
1292 break;
1293
1294 case MOUNT_REMOUNTING_SIGTERM:
1295 if (m->kill_context.send_sigkill) {
1296 log_unit_warning(UNIT(m)->id,
1297 "%s remounting timed out. Killing.", UNIT(m)->id);
1298 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1299 } else {
1300 log_unit_warning(UNIT(m)->id,
1301 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1302 UNIT(m)->id);
1303
1304 if (m->from_proc_self_mountinfo)
1305 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1306 else
1307 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1308 }
1309 break;
1310
1311 case MOUNT_UNMOUNTING_SIGTERM:
1312 if (m->kill_context.send_sigkill) {
1313 log_unit_warning(UNIT(m)->id,
1314 "%s unmounting timed out. Killing.", UNIT(m)->id);
1315 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1316 } else {
1317 log_unit_warning(UNIT(m)->id,
1318 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1319 UNIT(m)->id);
1320
1321 if (m->from_proc_self_mountinfo)
1322 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1323 else
1324 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1325 }
1326 break;
1327
1328 case MOUNT_MOUNTING_SIGKILL:
1329 case MOUNT_REMOUNTING_SIGKILL:
1330 case MOUNT_UNMOUNTING_SIGKILL:
1331 log_unit_warning(UNIT(m)->id,
1332 "%s mount process still around after SIGKILL. Ignoring.",
1333 UNIT(m)->id);
1334
1335 if (m->from_proc_self_mountinfo)
1336 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1337 else
1338 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1339 break;
1340
1341 default:
1342 assert_not_reached("Timeout at wrong time.");
1343 }
1344
1345 return 0;
1346 }
1347
1348 static int mount_add_one(
1349 Manager *m,
1350 const char *what,
1351 const char *where,
1352 const char *options,
1353 const char *fstype,
1354 bool set_flags) {
1355
1356 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1357 bool load_extras = false;
1358 MountParameters *p;
1359 bool delete, changed = false;
1360 Unit *u;
1361 int r;
1362
1363 assert(m);
1364 assert(what);
1365 assert(where);
1366 assert(options);
1367 assert(fstype);
1368
1369 /* Ignore API mount points. They should never be referenced in
1370 * dependencies ever. */
1371 if (mount_point_is_api(where) || mount_point_ignore(where))
1372 return 0;
1373
1374 if (streq(fstype, "autofs"))
1375 return 0;
1376
1377 /* probably some kind of swap, ignore */
1378 if (!is_path(where))
1379 return 0;
1380
1381 e = unit_name_from_path(where, ".mount");
1382 if (!e)
1383 return -ENOMEM;
1384
1385 u = manager_get_unit(m, e);
1386 if (!u) {
1387 delete = true;
1388
1389 u = unit_new(m, sizeof(Mount));
1390 if (!u)
1391 return -ENOMEM;
1392
1393 r = unit_add_name(u, e);
1394 if (r < 0)
1395 goto fail;
1396
1397 MOUNT(u)->where = strdup(where);
1398 if (!MOUNT(u)->where) {
1399 r = -ENOMEM;
1400 goto fail;
1401 }
1402
1403 u->source_path = strdup("/proc/self/mountinfo");
1404 if (!u->source_path) {
1405 r = -ENOMEM;
1406 goto fail;
1407 }
1408
1409
1410 if (m->running_as == SYSTEMD_SYSTEM) {
1411 const char* target;
1412
1413 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1414
1415 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1416 if (r < 0)
1417 goto fail;
1418
1419 if (should_umount(MOUNT(u))) {
1420 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1421 if (r < 0)
1422 goto fail;
1423 }
1424 }
1425
1426 unit_add_to_load_queue(u);
1427 changed = true;
1428 } else {
1429 delete = false;
1430
1431 if (!MOUNT(u)->where) {
1432 MOUNT(u)->where = strdup(where);
1433 if (!MOUNT(u)->where) {
1434 r = -ENOMEM;
1435 goto fail;
1436 }
1437 }
1438
1439 if (u->load_state == UNIT_NOT_FOUND) {
1440 u->load_state = UNIT_LOADED;
1441 u->load_error = 0;
1442
1443 /* Load in the extras later on, after we
1444 * finished initialization of the unit */
1445 load_extras = true;
1446 changed = true;
1447 }
1448 }
1449
1450 w = strdup(what);
1451 o = strdup(options);
1452 f = strdup(fstype);
1453 if (!w || !o || !f) {
1454 r = -ENOMEM;
1455 goto fail;
1456 }
1457
1458 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1459
1460 changed = changed ||
1461 !streq_ptr(p->options, options) ||
1462 !streq_ptr(p->what, what) ||
1463 !streq_ptr(p->fstype, fstype);
1464
1465 if (set_flags) {
1466 MOUNT(u)->is_mounted = true;
1467 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1468 MOUNT(u)->just_changed = changed;
1469 }
1470
1471 MOUNT(u)->from_proc_self_mountinfo = true;
1472
1473 free(p->what);
1474 p->what = w;
1475 w = NULL;
1476
1477 free(p->options);
1478 p->options = o;
1479 o = NULL;
1480
1481 free(p->fstype);
1482 p->fstype = f;
1483 f = NULL;
1484
1485 if (load_extras) {
1486 r = mount_add_extras(MOUNT(u));
1487 if (r < 0)
1488 goto fail;
1489 }
1490
1491 if (changed)
1492 unit_add_to_dbus_queue(u);
1493
1494 return 0;
1495
1496 fail:
1497 if (delete && u)
1498 unit_free(u);
1499
1500 return r;
1501 }
1502
1503 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1504 int r = 0;
1505 unsigned i;
1506
1507 assert(m);
1508
1509 rewind(m->proc_self_mountinfo);
1510
1511 for (i = 1;; i++) {
1512 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1513 int k;
1514
1515 k = fscanf(m->proc_self_mountinfo,
1516 "%*s " /* (1) mount id */
1517 "%*s " /* (2) parent id */
1518 "%*s " /* (3) major:minor */
1519 "%*s " /* (4) root */
1520 "%ms " /* (5) mount point */
1521 "%ms" /* (6) mount options */
1522 "%*[^-]" /* (7) optional fields */
1523 "- " /* (8) separator */
1524 "%ms " /* (9) file system type */
1525 "%ms" /* (10) mount source */
1526 "%ms" /* (11) mount options 2 */
1527 "%*[^\n]", /* some rubbish at the end */
1528 &path,
1529 &options,
1530 &fstype,
1531 &device,
1532 &options2);
1533
1534 if (k == EOF)
1535 break;
1536
1537 if (k != 5) {
1538 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1539 continue;
1540 }
1541
1542 o = strjoin(options, ",", options2, NULL);
1543 if (!o)
1544 return log_oom();
1545
1546 d = cunescape(device);
1547 p = cunescape(path);
1548 if (!d || !p)
1549 return log_oom();
1550
1551 k = mount_add_one(m, d, p, o, fstype, set_flags);
1552 if (k < 0)
1553 r = k;
1554 }
1555
1556 return r;
1557 }
1558
1559 static void mount_shutdown(Manager *m) {
1560 assert(m);
1561
1562 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1563
1564 if (m->proc_self_mountinfo) {
1565 fclose(m->proc_self_mountinfo);
1566 m->proc_self_mountinfo = NULL;
1567 }
1568 }
1569
1570 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1571 Mount *m = MOUNT(u);
1572 int r;
1573
1574 if (!m->timer_event_source)
1575 return 0;
1576
1577 r = sd_event_source_get_time(m->timer_event_source, timeout);
1578 if (r < 0)
1579 return r;
1580
1581 return 1;
1582 }
1583
1584 static int mount_enumerate(Manager *m) {
1585 int r;
1586 assert(m);
1587
1588 if (!m->proc_self_mountinfo) {
1589 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1590 if (!m->proc_self_mountinfo)
1591 return -errno;
1592
1593 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1594 if (r < 0)
1595 goto fail;
1596
1597 /* Dispatch this before we dispatch SIGCHLD, so that
1598 * we always get the events from /proc/self/mountinfo
1599 * before the SIGCHLD of /bin/mount. */
1600 r = sd_event_source_set_priority(m->mount_event_source, -10);
1601 if (r < 0)
1602 goto fail;
1603 }
1604
1605 r = mount_load_proc_self_mountinfo(m, false);
1606 if (r < 0)
1607 goto fail;
1608
1609 return 0;
1610
1611 fail:
1612 mount_shutdown(m);
1613 return r;
1614 }
1615
1616 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1617 Manager *m = userdata;
1618 Unit *u;
1619 int r;
1620
1621 assert(m);
1622 assert(revents & EPOLLPRI);
1623
1624 /* The manager calls this for every fd event happening on the
1625 * /proc/self/mountinfo file, which informs us about mounting
1626 * table changes */
1627
1628 r = mount_load_proc_self_mountinfo(m, true);
1629 if (r < 0) {
1630 log_error_errno(r, "Failed to reread /proc/self/mountinfo: %m");
1631
1632 /* Reset flags, just in case, for later calls */
1633 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1634 Mount *mount = MOUNT(u);
1635
1636 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1637 }
1638
1639 return 0;
1640 }
1641
1642 manager_dispatch_load_queue(m);
1643
1644 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1645 Mount *mount = MOUNT(u);
1646
1647 if (!mount->is_mounted) {
1648
1649 mount->from_proc_self_mountinfo = false;
1650
1651 switch (mount->state) {
1652
1653 case MOUNT_MOUNTED:
1654 /* This has just been unmounted by
1655 * somebody else, follow the state
1656 * change. */
1657 mount_enter_dead(mount, MOUNT_SUCCESS);
1658 break;
1659
1660 default:
1661 break;
1662 }
1663
1664 } else if (mount->just_mounted || mount->just_changed) {
1665
1666 /* New or changed mount entry */
1667
1668 switch (mount->state) {
1669
1670 case MOUNT_DEAD:
1671 case MOUNT_FAILED:
1672 /* This has just been mounted by
1673 * somebody else, follow the state
1674 * change. */
1675 mount_enter_mounted(mount, MOUNT_SUCCESS);
1676 break;
1677
1678 case MOUNT_MOUNTING:
1679 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1680 break;
1681
1682 default:
1683 /* Nothing really changed, but let's
1684 * issue an notification call
1685 * nonetheless, in case somebody is
1686 * waiting for this. (e.g. file system
1687 * ro/rw remounts.) */
1688 mount_set_state(mount, mount->state);
1689 break;
1690 }
1691 }
1692
1693 /* Reset the flags for later calls */
1694 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1695 }
1696
1697 return 0;
1698 }
1699
1700 static void mount_reset_failed(Unit *u) {
1701 Mount *m = MOUNT(u);
1702
1703 assert(m);
1704
1705 if (m->state == MOUNT_FAILED)
1706 mount_set_state(m, MOUNT_DEAD);
1707
1708 m->result = MOUNT_SUCCESS;
1709 m->reload_result = MOUNT_SUCCESS;
1710 }
1711
1712 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1713 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1714 }
1715
1716 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1717 [MOUNT_DEAD] = "dead",
1718 [MOUNT_MOUNTING] = "mounting",
1719 [MOUNT_MOUNTING_DONE] = "mounting-done",
1720 [MOUNT_MOUNTED] = "mounted",
1721 [MOUNT_REMOUNTING] = "remounting",
1722 [MOUNT_UNMOUNTING] = "unmounting",
1723 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1724 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1725 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1726 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1727 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1728 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1729 [MOUNT_FAILED] = "failed"
1730 };
1731
1732 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1733
1734 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1735 [MOUNT_EXEC_MOUNT] = "ExecMount",
1736 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1737 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1738 };
1739
1740 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1741
1742 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1743 [MOUNT_SUCCESS] = "success",
1744 [MOUNT_FAILURE_RESOURCES] = "resources",
1745 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1746 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1747 [MOUNT_FAILURE_SIGNAL] = "signal",
1748 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1749 };
1750
1751 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1752
1753 const UnitVTable mount_vtable = {
1754 .object_size = sizeof(Mount),
1755 .exec_context_offset = offsetof(Mount, exec_context),
1756 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1757 .kill_context_offset = offsetof(Mount, kill_context),
1758 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1759
1760 .sections =
1761 "Unit\0"
1762 "Mount\0"
1763 "Install\0",
1764 .private_section = "Mount",
1765
1766 .no_alias = true,
1767 .no_instances = true,
1768
1769 .init = mount_init,
1770 .load = mount_load,
1771 .done = mount_done,
1772
1773 .coldplug = mount_coldplug,
1774
1775 .dump = mount_dump,
1776
1777 .start = mount_start,
1778 .stop = mount_stop,
1779 .reload = mount_reload,
1780
1781 .kill = mount_kill,
1782
1783 .serialize = mount_serialize,
1784 .deserialize_item = mount_deserialize_item,
1785
1786 .active_state = mount_active_state,
1787 .sub_state_to_string = mount_sub_state_to_string,
1788
1789 .check_gc = mount_check_gc,
1790
1791 .sigchld_event = mount_sigchld_event,
1792
1793 .reset_failed = mount_reset_failed,
1794
1795 .bus_interface = "org.freedesktop.systemd1.Mount",
1796 .bus_vtable = bus_mount_vtable,
1797 .bus_set_property = bus_mount_set_property,
1798 .bus_commit_properties = bus_mount_commit_properties,
1799
1800 .get_timeout = mount_get_timeout,
1801
1802 .can_transient = true,
1803
1804 .enumerate = mount_enumerate,
1805 .shutdown = mount_shutdown,
1806
1807 .status_message_formats = {
1808 .starting_stopping = {
1809 [0] = "Mounting %s...",
1810 [1] = "Unmounting %s...",
1811 },
1812 .finished_start_job = {
1813 [JOB_DONE] = "Mounted %s.",
1814 [JOB_FAILED] = "Failed to mount %s.",
1815 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1816 [JOB_TIMEOUT] = "Timed out mounting %s.",
1817 },
1818 .finished_stop_job = {
1819 [JOB_DONE] = "Unmounted %s.",
1820 [JOB_FAILED] = "Failed unmounting %s.",
1821 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1822 },
1823 },
1824 };
Unnamed repository; edit this file 'description' to name the repository.