]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/mount.c
projects / thirdparty / systemd.git / blob
? search:


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