]> 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
mount: add new SloppyOptions= setting for mount units, mapping to mount(8)'s "-s...
[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 return 0;
385
386 if (mount_is_network(p)) {
387 after = SPECIAL_REMOTE_FS_PRE_TARGET;
388 after2 = SPECIAL_NETWORK_TARGET;
389 online = SPECIAL_NETWORK_ONLINE_TARGET;
390 } else {
391 after = SPECIAL_LOCAL_FS_PRE_TARGET;
392 after2 = NULL;
393 online = NULL;
394 }
395
396 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
397 if (r < 0)
398 return r;
399
400 if (after2) {
401 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
402 if (r < 0)
403 return r;
404 }
405
406 if (online) {
407 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
408 if (r < 0)
409 return r;
410 }
411
412 if (should_umount(m)) {
413 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
414 if (r < 0)
415 return r;
416 }
417
418 return 0;
419 }
420
421 static int mount_fix_timeouts(Mount *m) {
422 MountParameters *p;
423 const char *timeout = NULL;
424 Unit *other;
425 Iterator i;
426 usec_t u;
427 char *t;
428 int r;
429
430 assert(m);
431
432 p = get_mount_parameters_fragment(m);
433 if (!p)
434 return 0;
435
436 /* Allow configuration how long we wait for a device that
437 * backs a mount point to show up. This is useful to support
438 * endless device timeouts for devices that show up only after
439 * user input, like crypto devices. */
440
441 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
442 timeout += 31;
443 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
444 timeout += 25;
445 else
446 return 0;
447
448 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
449 if (!t)
450 return -ENOMEM;
451
452 r = parse_sec(t, &u);
453 free(t);
454
455 if (r < 0) {
456 log_warning_unit(UNIT(m)->id,
457 "Failed to parse timeout for %s, ignoring: %s",
458 m->where, timeout);
459 return r;
460 }
461
462 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
463 if (other->type != UNIT_DEVICE)
464 continue;
465
466 other->job_timeout = u;
467 }
468
469 return 0;
470 }
471
472 static int mount_verify(Mount *m) {
473 _cleanup_free_ char *e = NULL;
474 bool b;
475
476 assert(m);
477
478 if (UNIT(m)->load_state != UNIT_LOADED)
479 return 0;
480
481 if (!m->from_fragment && !m->from_proc_self_mountinfo)
482 return -ENOENT;
483
484 e = unit_name_from_path(m->where, ".mount");
485 if (!e)
486 return -ENOMEM;
487
488 b = unit_has_name(UNIT(m), e);
489 if (!b) {
490 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
491 return -EINVAL;
492 }
493
494 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
495 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
496 return -EINVAL;
497 }
498
499 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
500 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
501 return -EBADMSG;
502 }
503
504 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
505 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
506 return -EINVAL;
507 }
508
509 return 0;
510 }
511
512 static int mount_add_extras(Mount *m) {
513 Unit *u = UNIT(m);
514 int r;
515
516 assert(m);
517
518 if (u->fragment_path)
519 m->from_fragment = true;
520
521 if (!m->where) {
522 m->where = unit_name_to_path(u->id);
523 if (!m->where)
524 return -ENOMEM;
525 }
526
527 path_kill_slashes(m->where);
528
529 if (!u->description) {
530 r = unit_set_description(u, m->where);
531 if (r < 0)
532 return r;
533 }
534
535 r = mount_add_device_links(m);
536 if (r < 0)
537 return r;
538
539 r = mount_add_mount_links(m);
540 if (r < 0)
541 return r;
542
543 r = mount_add_quota_links(m);
544 if (r < 0)
545 return r;
546
547 r = unit_patch_contexts(u);
548 if (r < 0)
549 return r;
550
551 r = unit_add_exec_dependencies(u, &m->exec_context);
552 if (r < 0)
553 return r;
554
555 r = unit_add_default_slice(u, &m->cgroup_context);
556 if (r < 0)
557 return r;
558
559 r = mount_fix_timeouts(m);
560 if (r < 0)
561 return r;
562
563 if (u->default_dependencies) {
564 r = mount_add_default_dependencies(m);
565 if (r < 0)
566 return r;
567 }
568
569 return 0;
570 }
571
572 static int mount_load(Unit *u) {
573 Mount *m = MOUNT(u);
574 int r;
575
576 assert(u);
577 assert(u->load_state == UNIT_STUB);
578
579 if (m->from_proc_self_mountinfo)
580 r = unit_load_fragment_and_dropin_optional(u);
581 else
582 r = unit_load_fragment_and_dropin(u);
583
584 if (r < 0)
585 return r;
586
587 /* This is a new unit? Then let's add in some extras */
588 if (u->load_state == UNIT_LOADED) {
589 r = mount_add_extras(m);
590 if (r < 0)
591 return r;
592 }
593
594 return mount_verify(m);
595 }
596
597 static int mount_notify_automount(Mount *m, int status) {
598 Unit *p;
599 int r;
600 Iterator i;
601
602 assert(m);
603
604 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
605 if (p->type == UNIT_AUTOMOUNT) {
606 r = automount_send_ready(AUTOMOUNT(p), status);
607 if (r < 0)
608 return r;
609 }
610
611 return 0;
612 }
613
614 static void mount_set_state(Mount *m, MountState state) {
615 MountState old_state;
616 assert(m);
617
618 old_state = m->state;
619 m->state = state;
620
621 if (state != MOUNT_MOUNTING &&
622 state != MOUNT_MOUNTING_DONE &&
623 state != MOUNT_REMOUNTING &&
624 state != MOUNT_UNMOUNTING &&
625 state != MOUNT_MOUNTING_SIGTERM &&
626 state != MOUNT_MOUNTING_SIGKILL &&
627 state != MOUNT_UNMOUNTING_SIGTERM &&
628 state != MOUNT_UNMOUNTING_SIGKILL &&
629 state != MOUNT_REMOUNTING_SIGTERM &&
630 state != MOUNT_REMOUNTING_SIGKILL) {
631 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
632 mount_unwatch_control_pid(m);
633 m->control_command = NULL;
634 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
635 }
636
637 if (state == MOUNT_MOUNTED ||
638 state == MOUNT_REMOUNTING)
639 mount_notify_automount(m, 0);
640 else if (state == MOUNT_DEAD ||
641 state == MOUNT_UNMOUNTING ||
642 state == MOUNT_MOUNTING_SIGTERM ||
643 state == MOUNT_MOUNTING_SIGKILL ||
644 state == MOUNT_REMOUNTING_SIGTERM ||
645 state == MOUNT_REMOUNTING_SIGKILL ||
646 state == MOUNT_UNMOUNTING_SIGTERM ||
647 state == MOUNT_UNMOUNTING_SIGKILL ||
648 state == MOUNT_FAILED) {
649 if (state != old_state)
650 mount_notify_automount(m, -ENODEV);
651 }
652
653 if (state != old_state)
654 log_debug_unit(UNIT(m)->id,
655 "%s changed %s -> %s",
656 UNIT(m)->id,
657 mount_state_to_string(old_state),
658 mount_state_to_string(state));
659
660 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
661 m->reload_result = MOUNT_SUCCESS;
662 }
663
664 static int mount_coldplug(Unit *u) {
665 Mount *m = MOUNT(u);
666 MountState new_state = MOUNT_DEAD;
667 int r;
668
669 assert(m);
670 assert(m->state == MOUNT_DEAD);
671
672 if (m->deserialized_state != m->state)
673 new_state = m->deserialized_state;
674 else if (m->from_proc_self_mountinfo)
675 new_state = MOUNT_MOUNTED;
676
677 if (new_state == m->state)
678 return 0;
679
680 if (new_state == MOUNT_MOUNTING ||
681 new_state == MOUNT_MOUNTING_DONE ||
682 new_state == MOUNT_REMOUNTING ||
683 new_state == MOUNT_UNMOUNTING ||
684 new_state == MOUNT_MOUNTING_SIGTERM ||
685 new_state == MOUNT_MOUNTING_SIGKILL ||
686 new_state == MOUNT_UNMOUNTING_SIGTERM ||
687 new_state == MOUNT_UNMOUNTING_SIGKILL ||
688 new_state == MOUNT_REMOUNTING_SIGTERM ||
689 new_state == MOUNT_REMOUNTING_SIGKILL) {
690
691 if (m->control_pid <= 0)
692 return -EBADMSG;
693
694 r = unit_watch_pid(UNIT(m), m->control_pid);
695 if (r < 0)
696 return r;
697
698 r = mount_arm_timer(m);
699 if (r < 0)
700 return r;
701 }
702
703 mount_set_state(m, new_state);
704 return 0;
705 }
706
707 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
708 Mount *m = MOUNT(u);
709 MountParameters *p;
710
711 assert(m);
712 assert(f);
713
714 p = get_mount_parameters(m);
715
716 fprintf(f,
717 "%sMount State: %s\n"
718 "%sResult: %s\n"
719 "%sWhere: %s\n"
720 "%sWhat: %s\n"
721 "%sFile System Type: %s\n"
722 "%sOptions: %s\n"
723 "%sFrom /proc/self/mountinfo: %s\n"
724 "%sFrom fragment: %s\n"
725 "%sDirectoryMode: %04o\n",
726 prefix, mount_state_to_string(m->state),
727 prefix, mount_result_to_string(m->result),
728 prefix, m->where,
729 prefix, p ? strna(p->what) : "n/a",
730 prefix, p ? strna(p->fstype) : "n/a",
731 prefix, p ? strna(p->options) : "n/a",
732 prefix, yes_no(m->from_proc_self_mountinfo),
733 prefix, yes_no(m->from_fragment),
734 prefix, m->directory_mode);
735
736 if (m->control_pid > 0)
737 fprintf(f,
738 "%sControl PID: "PID_FMT"\n",
739 prefix, m->control_pid);
740
741 exec_context_dump(&m->exec_context, f, prefix);
742 kill_context_dump(&m->kill_context, f, prefix);
743 }
744
745 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
746 pid_t pid;
747 int r;
748
749 assert(m);
750 assert(c);
751 assert(_pid);
752
753 unit_realize_cgroup(UNIT(m));
754
755 r = unit_setup_exec_runtime(UNIT(m));
756 if (r < 0)
757 goto fail;
758
759 r = mount_arm_timer(m);
760 if (r < 0)
761 goto fail;
762
763 r = exec_spawn(c,
764 NULL,
765 &m->exec_context,
766 NULL, 0,
767 UNIT(m)->manager->environment,
768 true,
769 true,
770 true,
771 UNIT(m)->manager->confirm_spawn,
772 UNIT(m)->manager->cgroup_supported,
773 UNIT(m)->cgroup_path,
774 manager_get_runtime_prefix(UNIT(m)->manager),
775 UNIT(m)->id,
776 0,
777 NULL,
778 m->exec_runtime,
779 &pid);
780 if (r < 0)
781 goto fail;
782
783 r = unit_watch_pid(UNIT(m), pid);
784 if (r < 0)
785 /* FIXME: we need to do something here */
786 goto fail;
787
788 *_pid = pid;
789
790 return 0;
791
792 fail:
793 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
794
795 return r;
796 }
797
798 static void mount_enter_dead(Mount *m, MountResult f) {
799 assert(m);
800
801 if (f != MOUNT_SUCCESS)
802 m->result = f;
803
804 exec_runtime_destroy(m->exec_runtime);
805 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
806
807 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
808
809 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
810 }
811
812 static void mount_enter_mounted(Mount *m, MountResult f) {
813 assert(m);
814
815 if (f != MOUNT_SUCCESS)
816 m->result = f;
817
818 mount_set_state(m, MOUNT_MOUNTED);
819 }
820
821 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
822 int r;
823
824 assert(m);
825
826 if (f != MOUNT_SUCCESS)
827 m->result = f;
828
829 r = unit_kill_context(
830 UNIT(m),
831 &m->kill_context,
832 state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
833 -1,
834 m->control_pid,
835 false);
836 if (r < 0)
837 goto fail;
838
839 if (r > 0) {
840 r = mount_arm_timer(m);
841 if (r < 0)
842 goto fail;
843
844 mount_set_state(m, state);
845 } else if (state == MOUNT_REMOUNTING_SIGTERM)
846 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
847 else if (state == MOUNT_REMOUNTING_SIGKILL)
848 mount_enter_mounted(m, MOUNT_SUCCESS);
849 else if (state == MOUNT_MOUNTING_SIGTERM)
850 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
851 else if (state == MOUNT_UNMOUNTING_SIGTERM)
852 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
853 else
854 mount_enter_dead(m, MOUNT_SUCCESS);
855
856 return;
857
858 fail:
859 log_warning_unit(UNIT(m)->id,
860 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
861
862 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
863 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
864 else
865 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
866 }
867
868 void warn_if_dir_nonempty(const char *unit, const char* where) {
869 assert(unit);
870 assert(where);
871
872 if (dir_is_empty(where) > 0)
873 return;
874
875 log_struct_unit(LOG_NOTICE,
876 unit,
877 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
878 unit, where,
879 "WHERE=%s", where,
880 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
881 NULL);
882 }
883
884 static void mount_enter_unmounting(Mount *m) {
885 int r;
886
887 assert(m);
888
889 m->control_command_id = MOUNT_EXEC_UNMOUNT;
890 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
891
892 if ((r = exec_command_set(
893 m->control_command,
894 "/bin/umount",
895 "-n",
896 m->where,
897 NULL)) < 0)
898 goto fail;
899
900 mount_unwatch_control_pid(m);
901
902 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
903 goto fail;
904
905 mount_set_state(m, MOUNT_UNMOUNTING);
906
907 return;
908
909 fail:
910 log_warning_unit(UNIT(m)->id,
911 "%s failed to run 'umount' task: %s",
912 UNIT(m)->id, strerror(-r));
913 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
914 }
915
916 static void mount_enter_mounting(Mount *m) {
917 int r;
918 MountParameters *p;
919
920 assert(m);
921
922 m->control_command_id = MOUNT_EXEC_MOUNT;
923 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
924
925 mkdir_p_label(m->where, m->directory_mode);
926
927 warn_if_dir_nonempty(m->meta.id, m->where);
928
929 /* Create the source directory for bind-mounts if needed */
930 p = get_mount_parameters_fragment(m);
931 if (p && mount_is_bind(p))
932 mkdir_p_label(p->what, m->directory_mode);
933
934 if (m->from_fragment)
935 r = exec_command_set(
936 m->control_command,
937 "/bin/mount",
938 m->sloppy_options ? "-ns" : "-n",
939 m->parameters_fragment.what,
940 m->where,
941 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
942 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
943 NULL);
944 else
945 r = -ENOENT;
946
947 if (r < 0)
948 goto fail;
949
950 mount_unwatch_control_pid(m);
951
952 r = mount_spawn(m, m->control_command, &m->control_pid);
953 if (r < 0)
954 goto fail;
955
956 mount_set_state(m, MOUNT_MOUNTING);
957
958 return;
959
960 fail:
961 log_warning_unit(UNIT(m)->id,
962 "%s failed to run 'mount' task: %s",
963 UNIT(m)->id, strerror(-r));
964 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
965 }
966
967 static void mount_enter_remounting(Mount *m) {
968 int r;
969
970 assert(m);
971
972 m->control_command_id = MOUNT_EXEC_REMOUNT;
973 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
974
975 if (m->from_fragment) {
976 const char *o;
977
978 if (m->parameters_fragment.options)
979 o = strappenda("remount,", m->parameters_fragment.options);
980 else
981 o = "remount";
982
983 r = exec_command_set(
984 m->control_command,
985 "/bin/mount",
986 m->sloppy_options ? "-ns" : "-n",
987 m->parameters_fragment.what,
988 m->where,
989 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
990 "-o", o,
991 NULL);
992 } else
993 r = -ENOENT;
994
995 if (r < 0)
996 goto fail;
997
998 mount_unwatch_control_pid(m);
999
1000 r = mount_spawn(m, m->control_command, &m->control_pid);
1001 if (r < 0)
1002 goto fail;
1003
1004 mount_set_state(m, MOUNT_REMOUNTING);
1005
1006 return;
1007
1008 fail:
1009 log_warning_unit(UNIT(m)->id,
1010 "%s failed to run 'remount' task: %s",
1011 UNIT(m)->id, strerror(-r));
1012 m->reload_result = MOUNT_FAILURE_RESOURCES;
1013 mount_enter_mounted(m, MOUNT_SUCCESS);
1014 }
1015
1016 static int mount_start(Unit *u) {
1017 Mount *m = MOUNT(u);
1018
1019 assert(m);
1020
1021 /* We cannot fulfill this request right now, try again later
1022 * please! */
1023 if (m->state == MOUNT_UNMOUNTING ||
1024 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1025 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1026 m->state == MOUNT_MOUNTING_SIGTERM ||
1027 m->state == MOUNT_MOUNTING_SIGKILL)
1028 return -EAGAIN;
1029
1030 /* Already on it! */
1031 if (m->state == MOUNT_MOUNTING)
1032 return 0;
1033
1034 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1035
1036 m->result = MOUNT_SUCCESS;
1037 m->reload_result = MOUNT_SUCCESS;
1038
1039 mount_enter_mounting(m);
1040 return 0;
1041 }
1042
1043 static int mount_stop(Unit *u) {
1044 Mount *m = MOUNT(u);
1045
1046 assert(m);
1047
1048 /* Already on it */
1049 if (m->state == MOUNT_UNMOUNTING ||
1050 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1051 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1052 m->state == MOUNT_MOUNTING_SIGTERM ||
1053 m->state == MOUNT_MOUNTING_SIGKILL)
1054 return 0;
1055
1056 assert(m->state == MOUNT_MOUNTING ||
1057 m->state == MOUNT_MOUNTING_DONE ||
1058 m->state == MOUNT_MOUNTED ||
1059 m->state == MOUNT_REMOUNTING ||
1060 m->state == MOUNT_REMOUNTING_SIGTERM ||
1061 m->state == MOUNT_REMOUNTING_SIGKILL);
1062
1063 mount_enter_unmounting(m);
1064 return 0;
1065 }
1066
1067 static int mount_reload(Unit *u) {
1068 Mount *m = MOUNT(u);
1069
1070 assert(m);
1071
1072 if (m->state == MOUNT_MOUNTING_DONE)
1073 return -EAGAIN;
1074
1075 assert(m->state == MOUNT_MOUNTED);
1076
1077 mount_enter_remounting(m);
1078 return 0;
1079 }
1080
1081 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1082 Mount *m = MOUNT(u);
1083
1084 assert(m);
1085 assert(f);
1086 assert(fds);
1087
1088 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1089 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1090 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1091
1092 if (m->control_pid > 0)
1093 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1094
1095 if (m->control_command_id >= 0)
1096 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1097
1098 return 0;
1099 }
1100
1101 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1102 Mount *m = MOUNT(u);
1103
1104 assert(u);
1105 assert(key);
1106 assert(value);
1107 assert(fds);
1108
1109 if (streq(key, "state")) {
1110 MountState state;
1111
1112 if ((state = mount_state_from_string(value)) < 0)
1113 log_debug_unit(u->id, "Failed to parse state value %s", value);
1114 else
1115 m->deserialized_state = state;
1116 } else if (streq(key, "result")) {
1117 MountResult f;
1118
1119 f = mount_result_from_string(value);
1120 if (f < 0)
1121 log_debug_unit(UNIT(m)->id,
1122 "Failed to parse result value %s", value);
1123 else if (f != MOUNT_SUCCESS)
1124 m->result = f;
1125
1126 } else if (streq(key, "reload-result")) {
1127 MountResult f;
1128
1129 f = mount_result_from_string(value);
1130 if (f < 0)
1131 log_debug_unit(UNIT(m)->id,
1132 "Failed to parse reload result value %s", value);
1133 else if (f != MOUNT_SUCCESS)
1134 m->reload_result = f;
1135
1136 } else if (streq(key, "control-pid")) {
1137 pid_t pid;
1138
1139 if (parse_pid(value, &pid) < 0)
1140 log_debug_unit(UNIT(m)->id,
1141 "Failed to parse control-pid value %s", value);
1142 else
1143 m->control_pid = pid;
1144 } else if (streq(key, "control-command")) {
1145 MountExecCommand id;
1146
1147 if ((id = mount_exec_command_from_string(value)) < 0)
1148 log_debug_unit(UNIT(m)->id,
1149 "Failed to parse exec-command value %s", value);
1150 else {
1151 m->control_command_id = id;
1152 m->control_command = m->exec_command + id;
1153 }
1154 } else
1155 log_debug_unit(UNIT(m)->id,
1156 "Unknown serialization key '%s'", key);
1157
1158 return 0;
1159 }
1160
1161 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1162 assert(u);
1163
1164 return state_translation_table[MOUNT(u)->state];
1165 }
1166
1167 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1168 assert(u);
1169
1170 return mount_state_to_string(MOUNT(u)->state);
1171 }
1172
1173 _pure_ static bool mount_check_gc(Unit *u) {
1174 Mount *m = MOUNT(u);
1175
1176 assert(m);
1177
1178 return m->from_proc_self_mountinfo;
1179 }
1180
1181 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1182 Mount *m = MOUNT(u);
1183 MountResult f;
1184
1185 assert(m);
1186 assert(pid >= 0);
1187
1188 if (pid != m->control_pid)
1189 return;
1190
1191 m->control_pid = 0;
1192
1193 if (is_clean_exit(code, status, NULL))
1194 f = MOUNT_SUCCESS;
1195 else if (code == CLD_EXITED)
1196 f = MOUNT_FAILURE_EXIT_CODE;
1197 else if (code == CLD_KILLED)
1198 f = MOUNT_FAILURE_SIGNAL;
1199 else if (code == CLD_DUMPED)
1200 f = MOUNT_FAILURE_CORE_DUMP;
1201 else
1202 assert_not_reached("Unknown code");
1203
1204 if (f != MOUNT_SUCCESS)
1205 m->result = f;
1206
1207 if (m->control_command) {
1208 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1209
1210 m->control_command = NULL;
1211 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1212 }
1213
1214 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1215 "%s mount process exited, code=%s status=%i",
1216 u->id, sigchld_code_to_string(code), status);
1217
1218 /* Note that mount(8) returning and the kernel sending us a
1219 * mount table change event might happen out-of-order. If an
1220 * operation succeed we assume the kernel will follow soon too
1221 * and already change into the resulting state. If it fails
1222 * we check if the kernel still knows about the mount. and
1223 * change state accordingly. */
1224
1225 switch (m->state) {
1226
1227 case MOUNT_MOUNTING:
1228 case MOUNT_MOUNTING_DONE:
1229 case MOUNT_MOUNTING_SIGKILL:
1230 case MOUNT_MOUNTING_SIGTERM:
1231
1232 if (f == MOUNT_SUCCESS)
1233 mount_enter_mounted(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 case MOUNT_REMOUNTING:
1241 case MOUNT_REMOUNTING_SIGKILL:
1242 case MOUNT_REMOUNTING_SIGTERM:
1243
1244 m->reload_result = f;
1245 if (m->from_proc_self_mountinfo)
1246 mount_enter_mounted(m, MOUNT_SUCCESS);
1247 else
1248 mount_enter_dead(m, MOUNT_SUCCESS);
1249
1250 break;
1251
1252 case MOUNT_UNMOUNTING:
1253 case MOUNT_UNMOUNTING_SIGKILL:
1254 case MOUNT_UNMOUNTING_SIGTERM:
1255
1256 if (f == MOUNT_SUCCESS)
1257 mount_enter_dead(m, f);
1258 else if (m->from_proc_self_mountinfo)
1259 mount_enter_mounted(m, f);
1260 else
1261 mount_enter_dead(m, f);
1262 break;
1263
1264 default:
1265 assert_not_reached("Uh, control process died at wrong time.");
1266 }
1267
1268 /* Notify clients about changed exit status */
1269 unit_add_to_dbus_queue(u);
1270 }
1271
1272 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1273 Mount *m = MOUNT(userdata);
1274
1275 assert(m);
1276 assert(m->timer_event_source == source);
1277
1278 switch (m->state) {
1279
1280 case MOUNT_MOUNTING:
1281 case MOUNT_MOUNTING_DONE:
1282 log_warning_unit(UNIT(m)->id,
1283 "%s mounting timed out. Stopping.", UNIT(m)->id);
1284 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1285 break;
1286
1287 case MOUNT_REMOUNTING:
1288 log_warning_unit(UNIT(m)->id,
1289 "%s remounting timed out. Stopping.", UNIT(m)->id);
1290 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1291 mount_enter_mounted(m, MOUNT_SUCCESS);
1292 break;
1293
1294 case MOUNT_UNMOUNTING:
1295 log_warning_unit(UNIT(m)->id,
1296 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1297 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1298 break;
1299
1300 case MOUNT_MOUNTING_SIGTERM:
1301 if (m->kill_context.send_sigkill) {
1302 log_warning_unit(UNIT(m)->id,
1303 "%s mounting timed out. Killing.", UNIT(m)->id);
1304 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1305 } else {
1306 log_warning_unit(UNIT(m)->id,
1307 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1308 UNIT(m)->id);
1309
1310 if (m->from_proc_self_mountinfo)
1311 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1312 else
1313 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1314 }
1315 break;
1316
1317 case MOUNT_REMOUNTING_SIGTERM:
1318 if (m->kill_context.send_sigkill) {
1319 log_warning_unit(UNIT(m)->id,
1320 "%s remounting timed out. Killing.", UNIT(m)->id);
1321 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1322 } else {
1323 log_warning_unit(UNIT(m)->id,
1324 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1325 UNIT(m)->id);
1326
1327 if (m->from_proc_self_mountinfo)
1328 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1329 else
1330 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1331 }
1332 break;
1333
1334 case MOUNT_UNMOUNTING_SIGTERM:
1335 if (m->kill_context.send_sigkill) {
1336 log_warning_unit(UNIT(m)->id,
1337 "%s unmounting timed out. Killing.", UNIT(m)->id);
1338 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1339 } else {
1340 log_warning_unit(UNIT(m)->id,
1341 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1342 UNIT(m)->id);
1343
1344 if (m->from_proc_self_mountinfo)
1345 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1346 else
1347 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1348 }
1349 break;
1350
1351 case MOUNT_MOUNTING_SIGKILL:
1352 case MOUNT_REMOUNTING_SIGKILL:
1353 case MOUNT_UNMOUNTING_SIGKILL:
1354 log_warning_unit(UNIT(m)->id,
1355 "%s mount process still around after SIGKILL. Ignoring.",
1356 UNIT(m)->id);
1357
1358 if (m->from_proc_self_mountinfo)
1359 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1360 else
1361 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1362 break;
1363
1364 default:
1365 assert_not_reached("Timeout at wrong time.");
1366 }
1367
1368 return 0;
1369 }
1370
1371 static int mount_add_one(
1372 Manager *m,
1373 const char *what,
1374 const char *where,
1375 const char *options,
1376 const char *fstype,
1377 bool set_flags) {
1378
1379 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1380 bool load_extras = false;
1381 MountParameters *p;
1382 bool delete, changed = false;
1383 Unit *u;
1384 int r;
1385
1386 assert(m);
1387 assert(what);
1388 assert(where);
1389 assert(options);
1390 assert(fstype);
1391
1392 /* Ignore API mount points. They should never be referenced in
1393 * dependencies ever. */
1394 if (mount_point_is_api(where) || mount_point_ignore(where))
1395 return 0;
1396
1397 if (streq(fstype, "autofs"))
1398 return 0;
1399
1400 /* probably some kind of swap, ignore */
1401 if (!is_path(where))
1402 return 0;
1403
1404 e = unit_name_from_path(where, ".mount");
1405 if (!e)
1406 return -ENOMEM;
1407
1408 u = manager_get_unit(m, e);
1409 if (!u) {
1410 delete = true;
1411
1412 u = unit_new(m, sizeof(Mount));
1413 if (!u)
1414 return -ENOMEM;
1415
1416 r = unit_add_name(u, e);
1417 if (r < 0)
1418 goto fail;
1419
1420 MOUNT(u)->where = strdup(where);
1421 if (!MOUNT(u)->where) {
1422 r = -ENOMEM;
1423 goto fail;
1424 }
1425
1426 u->source_path = strdup("/proc/self/mountinfo");
1427 if (!u->source_path) {
1428 r = -ENOMEM;
1429 goto fail;
1430 }
1431
1432
1433 if (m->running_as == SYSTEMD_SYSTEM) {
1434 const char* target;
1435
1436 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1437
1438 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1439 if (r < 0)
1440 goto fail;
1441
1442 if (should_umount(MOUNT(u))) {
1443 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1444 if (r < 0)
1445 goto fail;
1446 }
1447 }
1448
1449 unit_add_to_load_queue(u);
1450 changed = true;
1451 } else {
1452 delete = false;
1453
1454 if (!MOUNT(u)->where) {
1455 MOUNT(u)->where = strdup(where);
1456 if (!MOUNT(u)->where) {
1457 r = -ENOMEM;
1458 goto fail;
1459 }
1460 }
1461
1462 if (u->load_state == UNIT_NOT_FOUND) {
1463 u->load_state = UNIT_LOADED;
1464 u->load_error = 0;
1465
1466 /* Load in the extras later on, after we
1467 * finished initialization of the unit */
1468 load_extras = true;
1469 changed = true;
1470 }
1471 }
1472
1473 w = strdup(what);
1474 o = strdup(options);
1475 f = strdup(fstype);
1476 if (!w || !o || !f) {
1477 r = -ENOMEM;
1478 goto fail;
1479 }
1480
1481 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1482
1483 changed = changed ||
1484 !streq_ptr(p->options, options) ||
1485 !streq_ptr(p->what, what) ||
1486 !streq_ptr(p->fstype, fstype);
1487
1488 if (set_flags) {
1489 MOUNT(u)->is_mounted = true;
1490 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1491 MOUNT(u)->just_changed = changed;
1492 }
1493
1494 MOUNT(u)->from_proc_self_mountinfo = true;
1495
1496 free(p->what);
1497 p->what = w;
1498 w = NULL;
1499
1500 free(p->options);
1501 p->options = o;
1502 o = NULL;
1503
1504 free(p->fstype);
1505 p->fstype = f;
1506 f = NULL;
1507
1508 if (load_extras) {
1509 r = mount_add_extras(MOUNT(u));
1510 if (r < 0)
1511 goto fail;
1512 }
1513
1514 if (changed)
1515 unit_add_to_dbus_queue(u);
1516
1517 return 0;
1518
1519 fail:
1520 if (delete && u)
1521 unit_free(u);
1522
1523 return r;
1524 }
1525
1526 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1527 int r = 0;
1528 unsigned i;
1529
1530 assert(m);
1531
1532 rewind(m->proc_self_mountinfo);
1533
1534 for (i = 1;; i++) {
1535 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1536 int k;
1537
1538 k = fscanf(m->proc_self_mountinfo,
1539 "%*s " /* (1) mount id */
1540 "%*s " /* (2) parent id */
1541 "%*s " /* (3) major:minor */
1542 "%*s " /* (4) root */
1543 "%ms " /* (5) mount point */
1544 "%ms" /* (6) mount options */
1545 "%*[^-]" /* (7) optional fields */
1546 "- " /* (8) separator */
1547 "%ms " /* (9) file system type */
1548 "%ms" /* (10) mount source */
1549 "%ms" /* (11) mount options 2 */
1550 "%*[^\n]", /* some rubbish at the end */
1551 &path,
1552 &options,
1553 &fstype,
1554 &device,
1555 &options2);
1556
1557 if (k == EOF)
1558 break;
1559
1560 if (k != 5) {
1561 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1562 continue;
1563 }
1564
1565 o = strjoin(options, ",", options2, NULL);
1566 if (!o)
1567 return log_oom();
1568
1569 d = cunescape(device);
1570 p = cunescape(path);
1571 if (!d || !p)
1572 return log_oom();
1573
1574 k = mount_add_one(m, d, p, o, fstype, set_flags);
1575 if (k < 0)
1576 r = k;
1577 }
1578
1579 return r;
1580 }
1581
1582 static void mount_shutdown(Manager *m) {
1583 assert(m);
1584
1585 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1586
1587 if (m->proc_self_mountinfo) {
1588 fclose(m->proc_self_mountinfo);
1589 m->proc_self_mountinfo = NULL;
1590 }
1591 }
1592
1593 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1594 Mount *m = MOUNT(u);
1595 int r;
1596
1597 if (!m->timer_event_source)
1598 return 0;
1599
1600 r = sd_event_source_get_time(m->timer_event_source, timeout);
1601 if (r < 0)
1602 return r;
1603
1604 return 1;
1605 }
1606
1607 static int mount_enumerate(Manager *m) {
1608 int r;
1609 assert(m);
1610
1611 if (!m->proc_self_mountinfo) {
1612 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1613 if (!m->proc_self_mountinfo)
1614 return -errno;
1615
1616 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1617 if (r < 0)
1618 goto fail;
1619
1620 /* Dispatch this before we dispatch SIGCHLD, so that
1621 * we always get the events from /proc/self/mountinfo
1622 * before the SIGCHLD of /bin/mount. */
1623 r = sd_event_source_set_priority(m->mount_event_source, -10);
1624 if (r < 0)
1625 goto fail;
1626 }
1627
1628 r = mount_load_proc_self_mountinfo(m, false);
1629 if (r < 0)
1630 goto fail;
1631
1632 return 0;
1633
1634 fail:
1635 mount_shutdown(m);
1636 return r;
1637 }
1638
1639 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1640 Manager *m = userdata;
1641 Unit *u;
1642 int r;
1643
1644 assert(m);
1645 assert(revents & EPOLLPRI);
1646
1647 /* The manager calls this for every fd event happening on the
1648 * /proc/self/mountinfo file, which informs us about mounting
1649 * table changes */
1650
1651 r = mount_load_proc_self_mountinfo(m, true);
1652 if (r < 0) {
1653 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1654
1655 /* Reset flags, just in case, for later calls */
1656 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1657 Mount *mount = MOUNT(u);
1658
1659 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1660 }
1661
1662 return 0;
1663 }
1664
1665 manager_dispatch_load_queue(m);
1666
1667 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1668 Mount *mount = MOUNT(u);
1669
1670 if (!mount->is_mounted) {
1671
1672 mount->from_proc_self_mountinfo = false;
1673
1674 switch (mount->state) {
1675
1676 case MOUNT_MOUNTED:
1677 /* This has just been unmounted by
1678 * somebody else, follow the state
1679 * change. */
1680 mount_enter_dead(mount, MOUNT_SUCCESS);
1681 break;
1682
1683 default:
1684 break;
1685 }
1686
1687 } else if (mount->just_mounted || mount->just_changed) {
1688
1689 /* New or changed mount entry */
1690
1691 switch (mount->state) {
1692
1693 case MOUNT_DEAD:
1694 case MOUNT_FAILED:
1695 /* This has just been mounted by
1696 * somebody else, follow the state
1697 * change. */
1698 mount_enter_mounted(mount, MOUNT_SUCCESS);
1699 break;
1700
1701 case MOUNT_MOUNTING:
1702 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1703 break;
1704
1705 default:
1706 /* Nothing really changed, but let's
1707 * issue an notification call
1708 * nonetheless, in case somebody is
1709 * waiting for this. (e.g. file system
1710 * ro/rw remounts.) */
1711 mount_set_state(mount, mount->state);
1712 break;
1713 }
1714 }
1715
1716 /* Reset the flags for later calls */
1717 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1718 }
1719
1720 return 0;
1721 }
1722
1723 static void mount_reset_failed(Unit *u) {
1724 Mount *m = MOUNT(u);
1725
1726 assert(m);
1727
1728 if (m->state == MOUNT_FAILED)
1729 mount_set_state(m, MOUNT_DEAD);
1730
1731 m->result = MOUNT_SUCCESS;
1732 m->reload_result = MOUNT_SUCCESS;
1733 }
1734
1735 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1736 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1737 }
1738
1739 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1740 [MOUNT_DEAD] = "dead",
1741 [MOUNT_MOUNTING] = "mounting",
1742 [MOUNT_MOUNTING_DONE] = "mounting-done",
1743 [MOUNT_MOUNTED] = "mounted",
1744 [MOUNT_REMOUNTING] = "remounting",
1745 [MOUNT_UNMOUNTING] = "unmounting",
1746 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1747 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1748 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1749 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1750 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1751 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1752 [MOUNT_FAILED] = "failed"
1753 };
1754
1755 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1756
1757 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1758 [MOUNT_EXEC_MOUNT] = "ExecMount",
1759 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1760 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1761 };
1762
1763 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1764
1765 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1766 [MOUNT_SUCCESS] = "success",
1767 [MOUNT_FAILURE_RESOURCES] = "resources",
1768 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1769 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1770 [MOUNT_FAILURE_SIGNAL] = "signal",
1771 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1772 };
1773
1774 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1775
1776 const UnitVTable mount_vtable = {
1777 .object_size = sizeof(Mount),
1778 .exec_context_offset = offsetof(Mount, exec_context),
1779 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1780 .kill_context_offset = offsetof(Mount, kill_context),
1781 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1782
1783 .sections =
1784 "Unit\0"
1785 "Mount\0"
1786 "Install\0",
1787 .private_section = "Mount",
1788
1789 .no_alias = true,
1790 .no_instances = true,
1791
1792 .init = mount_init,
1793 .load = mount_load,
1794 .done = mount_done,
1795
1796 .coldplug = mount_coldplug,
1797
1798 .dump = mount_dump,
1799
1800 .start = mount_start,
1801 .stop = mount_stop,
1802 .reload = mount_reload,
1803
1804 .kill = mount_kill,
1805
1806 .serialize = mount_serialize,
1807 .deserialize_item = mount_deserialize_item,
1808
1809 .active_state = mount_active_state,
1810 .sub_state_to_string = mount_sub_state_to_string,
1811
1812 .check_gc = mount_check_gc,
1813
1814 .sigchld_event = mount_sigchld_event,
1815
1816 .reset_failed = mount_reset_failed,
1817
1818 .bus_interface = "org.freedesktop.systemd1.Mount",
1819 .bus_vtable = bus_mount_vtable,
1820 .bus_set_property = bus_mount_set_property,
1821 .bus_commit_properties = bus_mount_commit_properties,
1822
1823 .get_timeout = mount_get_timeout,
1824
1825 .can_transient = true,
1826
1827 .enumerate = mount_enumerate,
1828 .shutdown = mount_shutdown,
1829
1830 .status_message_formats = {
1831 .starting_stopping = {
1832 [0] = "Mounting %s...",
1833 [1] = "Unmounting %s...",
1834 },
1835 .finished_start_job = {
1836 [JOB_DONE] = "Mounted %s.",
1837 [JOB_FAILED] = "Failed to mount %s.",
1838 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1839 [JOB_TIMEOUT] = "Timed out mounting %s.",
1840 },
1841 .finished_stop_job = {
1842 [JOB_DONE] = "Unmounted %s.",
1843 [JOB_FAILED] = "Failed unmounting %s.",
1844 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1845 },
1846 },
1847 };
Unnamed repository; edit this file 'description' to name the repository.