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