]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/mount.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mount: use libmount to enumerate /proc/self/mountinfo
[thirdparty/systemd.git] / src / core / mount.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <stdio.h>
24 #include <mntent.h>
25 #include <sys/epoll.h>
26 #include <signal.h>
27 #include <libmount.h>
28
29 #include "manager.h"
30 #include "unit.h"
31 #include "mount.h"
32 #include "load-fragment.h"
33 #include "load-dropin.h"
34 #include "log.h"
35 #include "sd-messages.h"
36 #include "strv.h"
37 #include "mkdir.h"
38 #include "path-util.h"
39 #include "mount-setup.h"
40 #include "unit-name.h"
41 #include "dbus-mount.h"
42 #include "special.h"
43 #include "bus-errors.h"
44 #include "exit-status.h"
45 #include "def.h"
46
47 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
48 [MOUNT_DEAD] = UNIT_INACTIVE,
49 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
50 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
51 [MOUNT_MOUNTED] = UNIT_ACTIVE,
52 [MOUNT_REMOUNTING] = UNIT_RELOADING,
53 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
54 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
55 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
56 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
57 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
58 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
59 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
60 [MOUNT_FAILED] = UNIT_FAILED
61 };
62
63 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
64 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
65
66 static bool mount_is_network(MountParameters *p) {
67 assert(p);
68
69 if (mount_test_option(p->options, "_netdev"))
70 return true;
71
72 if (p->fstype && fstype_is_network(p->fstype))
73 return true;
74
75 return false;
76 }
77
78 static bool mount_is_bind(MountParameters *p) {
79 assert(p);
80
81 if (mount_test_option(p->options, "bind"))
82 return true;
83
84 if (p->fstype && streq(p->fstype, "bind"))
85 return true;
86
87 if (mount_test_option(p->options, "rbind"))
88 return true;
89
90 if (p->fstype && streq(p->fstype, "rbind"))
91 return true;
92
93 return false;
94 }
95
96 static bool mount_is_auto(MountParameters *p) {
97 assert(p);
98
99 return !mount_test_option(p->options, "noauto");
100 }
101
102 static bool needs_quota(MountParameters *p) {
103 assert(p);
104
105 if (mount_is_network(p))
106 return false;
107
108 if (mount_is_bind(p))
109 return false;
110
111 return mount_test_option(p->options, "usrquota") ||
112 mount_test_option(p->options, "grpquota") ||
113 mount_test_option(p->options, "quota") ||
114 mount_test_option(p->options, "usrjquota") ||
115 mount_test_option(p->options, "grpjquota");
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 /bin/mount is always called in
139 * 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 return 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 }
174
175 static void mount_unwatch_control_pid(Mount *m) {
176 assert(m);
177
178 if (m->control_pid <= 0)
179 return;
180
181 unit_unwatch_pid(UNIT(m), m->control_pid);
182 m->control_pid = 0;
183 }
184
185 static void mount_parameters_done(MountParameters *p) {
186 assert(p);
187
188 free(p->what);
189 free(p->options);
190 free(p->fstype);
191
192 p->what = p->options = p->fstype = NULL;
193 }
194
195 static void mount_done(Unit *u) {
196 Mount *m = MOUNT(u);
197
198 assert(m);
199
200 free(m->where);
201 m->where = NULL;
202
203 mount_parameters_done(&m->parameters_proc_self_mountinfo);
204 mount_parameters_done(&m->parameters_fragment);
205
206 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
207 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
208 m->control_command = NULL;
209
210 mount_unwatch_control_pid(m);
211
212 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
213 }
214
215 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
216 assert(m);
217
218 if (m->from_fragment)
219 return &m->parameters_fragment;
220
221 return NULL;
222 }
223
224 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
225 assert(m);
226
227 if (m->from_proc_self_mountinfo)
228 return &m->parameters_proc_self_mountinfo;
229
230 return get_mount_parameters_fragment(m);
231 }
232
233 static int mount_add_mount_links(Mount *m) {
234 _cleanup_free_ char *parent = NULL;
235 MountParameters *pm;
236 Unit *other;
237 Iterator i;
238 Set *s;
239 int r;
240
241 assert(m);
242
243 if (!path_equal(m->where, "/")) {
244 /* Adds in links to other mount points that might lie further
245 * up in the hierarchy */
246 r = path_get_parent(m->where, &parent);
247 if (r < 0)
248 return r;
249
250 r = unit_require_mounts_for(UNIT(m), parent);
251 if (r < 0)
252 return r;
253 }
254
255 /* Adds in links to other mount points that might be needed
256 * for the source path (if this is a bind mount) to be
257 * available. */
258 pm = get_mount_parameters_fragment(m);
259 if (pm && pm->what &&
260 path_is_absolute(pm->what) &&
261 !mount_is_network(pm)) {
262
263 r = unit_require_mounts_for(UNIT(m), pm->what);
264 if (r < 0)
265 return r;
266 }
267
268 /* Adds in links to other units that use this path or paths
269 * further down in the hierarchy */
270 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
271 SET_FOREACH(other, s, i) {
272
273 if (other->load_state != UNIT_LOADED)
274 continue;
275
276 if (other == UNIT(m))
277 continue;
278
279 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
280 if (r < 0)
281 return r;
282
283 if (UNIT(m)->fragment_path) {
284 /* If we have fragment configuration, then make this dependency required */
285 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
286 if (r < 0)
287 return r;
288 }
289 }
290
291 return 0;
292 }
293
294 static int mount_add_device_links(Mount *m) {
295 MountParameters *p;
296 bool device_wants_mount = false;
297 int r;
298
299 assert(m);
300
301 p = get_mount_parameters_fragment(m);
302 if (!p)
303 return 0;
304
305 if (!p->what)
306 return 0;
307
308 if (mount_is_bind(p))
309 return 0;
310
311 if (!is_device_path(p->what))
312 return 0;
313
314 if (path_equal(m->where, "/"))
315 return 0;
316
317 if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
318 device_wants_mount = true;
319
320 r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
321 if (r < 0)
322 return r;
323
324 return 0;
325 }
326
327 static int mount_add_quota_links(Mount *m) {
328 int r;
329 MountParameters *p;
330
331 assert(m);
332
333 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
334 return 0;
335
336 p = get_mount_parameters_fragment(m);
337 if (!p)
338 return 0;
339
340 if (!needs_quota(p))
341 return 0;
342
343 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
344 if (r < 0)
345 return r;
346
347 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
348 if (r < 0)
349 return r;
350
351 return 0;
352 }
353
354 static bool should_umount(Mount *m) {
355 MountParameters *p;
356
357 if (path_equal(m->where, "/") ||
358 path_equal(m->where, "/usr"))
359 return false;
360
361 p = get_mount_parameters(m);
362 if (p && mount_test_option(p->options, "x-initrd.mount") &&
363 !in_initrd())
364 return false;
365
366 return true;
367 }
368
369 static int mount_add_default_dependencies(Mount *m) {
370 const char *after, *after2, *online;
371 MountParameters *p;
372 int r;
373
374 assert(m);
375
376 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
377 return 0;
378
379 p = get_mount_parameters(m);
380
381 if (!p)
382 return 0;
383
384 if (path_equal(m->where, "/") ||
385 path_equal(m->where, "/usr"))
386 return 0;
387
388 if (mount_is_network(p)) {
389 after = SPECIAL_REMOTE_FS_PRE_TARGET;
390 after2 = SPECIAL_NETWORK_TARGET;
391 online = SPECIAL_NETWORK_ONLINE_TARGET;
392 } else {
393 after = SPECIAL_LOCAL_FS_PRE_TARGET;
394 after2 = NULL;
395 online = NULL;
396 }
397
398 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
399 if (r < 0)
400 return r;
401
402 if (after2) {
403 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
404 if (r < 0)
405 return r;
406 }
407
408 if (online) {
409 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
410 if (r < 0)
411 return r;
412 }
413
414 if (should_umount(m)) {
415 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
416 if (r < 0)
417 return r;
418 }
419
420 return 0;
421 }
422
423 static int mount_verify(Mount *m) {
424 _cleanup_free_ char *e = NULL;
425 bool b;
426
427 assert(m);
428
429 if (UNIT(m)->load_state != UNIT_LOADED)
430 return 0;
431
432 if (!m->from_fragment && !m->from_proc_self_mountinfo)
433 return -ENOENT;
434
435 e = unit_name_from_path(m->where, ".mount");
436 if (!e)
437 return -ENOMEM;
438
439 b = unit_has_name(UNIT(m), e);
440 if (!b) {
441 log_unit_error(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
442 return -EINVAL;
443 }
444
445 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
446 log_unit_error(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
447 return -EINVAL;
448 }
449
450 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
451 log_unit_error(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
452 return -EBADMSG;
453 }
454
455 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
456 log_unit_error(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
457 return -EINVAL;
458 }
459
460 return 0;
461 }
462
463 static int mount_add_extras(Mount *m) {
464 Unit *u = UNIT(m);
465 int r;
466
467 assert(m);
468
469 if (u->fragment_path)
470 m->from_fragment = true;
471
472 if (!m->where) {
473 m->where = unit_name_to_path(u->id);
474 if (!m->where)
475 return -ENOMEM;
476 }
477
478 path_kill_slashes(m->where);
479
480 if (!u->description) {
481 r = unit_set_description(u, m->where);
482 if (r < 0)
483 return r;
484 }
485
486 r = mount_add_device_links(m);
487 if (r < 0)
488 return r;
489
490 r = mount_add_mount_links(m);
491 if (r < 0)
492 return r;
493
494 r = mount_add_quota_links(m);
495 if (r < 0)
496 return r;
497
498 r = unit_patch_contexts(u);
499 if (r < 0)
500 return r;
501
502 r = unit_add_exec_dependencies(u, &m->exec_context);
503 if (r < 0)
504 return r;
505
506 r = unit_add_default_slice(u, &m->cgroup_context);
507 if (r < 0)
508 return r;
509
510 if (u->default_dependencies) {
511 r = mount_add_default_dependencies(m);
512 if (r < 0)
513 return r;
514 }
515
516 return 0;
517 }
518
519 static int mount_load(Unit *u) {
520 Mount *m = MOUNT(u);
521 int r;
522
523 assert(u);
524 assert(u->load_state == UNIT_STUB);
525
526 if (m->from_proc_self_mountinfo)
527 r = unit_load_fragment_and_dropin_optional(u);
528 else
529 r = unit_load_fragment_and_dropin(u);
530
531 if (r < 0)
532 return r;
533
534 /* This is a new unit? Then let's add in some extras */
535 if (u->load_state == UNIT_LOADED) {
536 r = mount_add_extras(m);
537 if (r < 0)
538 return r;
539 }
540
541 return mount_verify(m);
542 }
543
544 static int mount_notify_automount(Mount *m, int status) {
545 Unit *p;
546 int r;
547 Iterator i;
548
549 assert(m);
550
551 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
552 if (p->type == UNIT_AUTOMOUNT) {
553 r = automount_send_ready(AUTOMOUNT(p), status);
554 if (r < 0)
555 return r;
556 }
557
558 return 0;
559 }
560
561 static void mount_set_state(Mount *m, MountState state) {
562 MountState old_state;
563 assert(m);
564
565 old_state = m->state;
566 m->state = state;
567
568 if (state != MOUNT_MOUNTING &&
569 state != MOUNT_MOUNTING_DONE &&
570 state != MOUNT_REMOUNTING &&
571 state != MOUNT_UNMOUNTING &&
572 state != MOUNT_MOUNTING_SIGTERM &&
573 state != MOUNT_MOUNTING_SIGKILL &&
574 state != MOUNT_UNMOUNTING_SIGTERM &&
575 state != MOUNT_UNMOUNTING_SIGKILL &&
576 state != MOUNT_REMOUNTING_SIGTERM &&
577 state != MOUNT_REMOUNTING_SIGKILL) {
578 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
579 mount_unwatch_control_pid(m);
580 m->control_command = NULL;
581 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
582 }
583
584 if (state == MOUNT_MOUNTED ||
585 state == MOUNT_REMOUNTING)
586 mount_notify_automount(m, 0);
587 else if (state == MOUNT_DEAD ||
588 state == MOUNT_UNMOUNTING ||
589 state == MOUNT_MOUNTING_SIGTERM ||
590 state == MOUNT_MOUNTING_SIGKILL ||
591 state == MOUNT_REMOUNTING_SIGTERM ||
592 state == MOUNT_REMOUNTING_SIGKILL ||
593 state == MOUNT_UNMOUNTING_SIGTERM ||
594 state == MOUNT_UNMOUNTING_SIGKILL ||
595 state == MOUNT_FAILED) {
596 if (state != old_state)
597 mount_notify_automount(m, -ENODEV);
598 }
599
600 if (state != old_state)
601 log_unit_debug(UNIT(m)->id,
602 "%s changed %s -> %s",
603 UNIT(m)->id,
604 mount_state_to_string(old_state),
605 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 };
700
701 assert(m);
702 assert(c);
703 assert(_pid);
704
705 unit_realize_cgroup(UNIT(m));
706
707 r = unit_setup_exec_runtime(UNIT(m));
708 if (r < 0)
709 goto fail;
710
711 r = mount_arm_timer(m);
712 if (r < 0)
713 goto fail;
714
715 exec_params.environment = UNIT(m)->manager->environment;
716 exec_params.confirm_spawn = UNIT(m)->manager->confirm_spawn;
717 exec_params.cgroup_supported = UNIT(m)->manager->cgroup_supported;
718 exec_params.cgroup_path = UNIT(m)->cgroup_path;
719 exec_params.cgroup_delegate = m->cgroup_context.delegate;
720 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
721 exec_params.unit_id = UNIT(m)->id;
722
723 r = exec_spawn(c,
724 &m->exec_context,
725 &exec_params,
726 m->exec_runtime,
727 &pid);
728 if (r < 0)
729 goto fail;
730
731 r = unit_watch_pid(UNIT(m), pid);
732 if (r < 0)
733 /* FIXME: we need to do something here */
734 goto fail;
735
736 *_pid = pid;
737
738 return 0;
739
740 fail:
741 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
742
743 return r;
744 }
745
746 static void mount_enter_dead(Mount *m, MountResult f) {
747 assert(m);
748
749 if (f != MOUNT_SUCCESS)
750 m->result = f;
751
752 exec_runtime_destroy(m->exec_runtime);
753 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
754
755 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
756
757 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
758 }
759
760 static void mount_enter_mounted(Mount *m, MountResult f) {
761 assert(m);
762
763 if (f != MOUNT_SUCCESS)
764 m->result = f;
765
766 mount_set_state(m, MOUNT_MOUNTED);
767 }
768
769 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
770 int r;
771
772 assert(m);
773
774 if (f != MOUNT_SUCCESS)
775 m->result = f;
776
777 r = unit_kill_context(
778 UNIT(m),
779 &m->kill_context,
780 (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
781 KILL_KILL : KILL_TERMINATE,
782 -1,
783 m->control_pid,
784 false);
785 if (r < 0)
786 goto fail;
787
788 if (r > 0) {
789 r = mount_arm_timer(m);
790 if (r < 0)
791 goto fail;
792
793 mount_set_state(m, state);
794 } else if (state == MOUNT_REMOUNTING_SIGTERM)
795 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
796 else if (state == MOUNT_REMOUNTING_SIGKILL)
797 mount_enter_mounted(m, MOUNT_SUCCESS);
798 else if (state == MOUNT_MOUNTING_SIGTERM)
799 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
800 else if (state == MOUNT_UNMOUNTING_SIGTERM)
801 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
802 else
803 mount_enter_dead(m, MOUNT_SUCCESS);
804
805 return;
806
807 fail:
808 log_unit_warning(UNIT(m)->id,
809 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
810
811 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
812 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
813 else
814 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
815 }
816
817 void warn_if_dir_nonempty(const char *unit, const char* where) {
818 int r;
819
820 assert(unit);
821 assert(where);
822
823 r = dir_is_empty(where);
824 if (r > 0)
825 return;
826 else if (r == 0)
827 log_unit_struct(unit,
828 LOG_NOTICE,
829 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
830 LOG_MESSAGE("%s: Directory %s to mount over is not empty, mounting anyway.",
831 unit, where),
832 "WHERE=%s", where,
833 NULL);
834 else
835 log_unit_warning(unit,
836 "MESSAGE=Failed to check directory %s: %s",
837 where, strerror(-r));
838 }
839
840 static int fail_if_symlink(const char *unit, const char* where) {
841 assert(where);
842
843 if (is_symlink(where) > 0) {
844 log_unit_struct(unit,
845 LOG_ERR,
846 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
847 LOG_MESSAGE("%s: Mount on symlink %s not allowed.",
848 unit, where),
849 "WHERE=%s", where,
850 NULL);
851
852 return -ELOOP;
853 }
854 return 0;
855 }
856
857 static void mount_enter_unmounting(Mount *m) {
858 int r;
859
860 assert(m);
861
862 m->control_command_id = MOUNT_EXEC_UNMOUNT;
863 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
864
865 if ((r = exec_command_set(
866 m->control_command,
867 "/bin/umount",
868 "-n",
869 m->where,
870 NULL)) < 0)
871 goto fail;
872
873 mount_unwatch_control_pid(m);
874
875 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
876 goto fail;
877
878 mount_set_state(m, MOUNT_UNMOUNTING);
879
880 return;
881
882 fail:
883 log_unit_warning(UNIT(m)->id,
884 "%s failed to run 'umount' task: %s",
885 UNIT(m)->id, strerror(-r));
886 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
887 }
888
889 static void mount_enter_mounting(Mount *m) {
890 int r;
891 MountParameters *p;
892
893 assert(m);
894
895 m->control_command_id = MOUNT_EXEC_MOUNT;
896 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
897
898 mkdir_p_label(m->where, m->directory_mode);
899
900 warn_if_dir_nonempty(m->meta.id, m->where);
901
902 /* Create the source directory for bind-mounts if needed */
903 p = get_mount_parameters_fragment(m);
904 if (p && mount_is_bind(p))
905 mkdir_p_label(p->what, m->directory_mode);
906
907 r = fail_if_symlink(m->meta.id, m->where);
908 if (r < 0)
909 goto fail;
910
911 if (m->from_fragment)
912 r = exec_command_set(
913 m->control_command,
914 "/bin/mount",
915 m->sloppy_options ? "-ns" : "-n",
916 m->parameters_fragment.what,
917 m->where,
918 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
919 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
920 NULL);
921 else
922 r = -ENOENT;
923
924 if (r < 0)
925 goto fail;
926
927 mount_unwatch_control_pid(m);
928
929 r = mount_spawn(m, m->control_command, &m->control_pid);
930 if (r < 0)
931 goto fail;
932
933 mount_set_state(m, MOUNT_MOUNTING);
934
935 return;
936
937 fail:
938 log_unit_warning(UNIT(m)->id,
939 "%s failed to run 'mount' task: %s",
940 UNIT(m)->id, strerror(-r));
941 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
942 }
943
944 static void mount_enter_remounting(Mount *m) {
945 int r;
946
947 assert(m);
948
949 m->control_command_id = MOUNT_EXEC_REMOUNT;
950 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
951
952 if (m->from_fragment) {
953 const char *o;
954
955 if (m->parameters_fragment.options)
956 o = strappenda("remount,", m->parameters_fragment.options);
957 else
958 o = "remount";
959
960 r = exec_command_set(
961 m->control_command,
962 "/bin/mount",
963 m->sloppy_options ? "-ns" : "-n",
964 m->parameters_fragment.what,
965 m->where,
966 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
967 "-o", o,
968 NULL);
969 } else
970 r = -ENOENT;
971
972 if (r < 0)
973 goto fail;
974
975 mount_unwatch_control_pid(m);
976
977 r = mount_spawn(m, m->control_command, &m->control_pid);
978 if (r < 0)
979 goto fail;
980
981 mount_set_state(m, MOUNT_REMOUNTING);
982
983 return;
984
985 fail:
986 log_unit_warning(UNIT(m)->id,
987 "%s failed to run 'remount' task: %s",
988 UNIT(m)->id, strerror(-r));
989 m->reload_result = MOUNT_FAILURE_RESOURCES;
990 mount_enter_mounted(m, MOUNT_SUCCESS);
991 }
992
993 static int mount_start(Unit *u) {
994 Mount *m = MOUNT(u);
995
996 assert(m);
997
998 /* We cannot fulfill this request right now, try again later
999 * please! */
1000 if (m->state == MOUNT_UNMOUNTING ||
1001 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1002 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1003 m->state == MOUNT_MOUNTING_SIGTERM ||
1004 m->state == MOUNT_MOUNTING_SIGKILL)
1005 return -EAGAIN;
1006
1007 /* Already on it! */
1008 if (m->state == MOUNT_MOUNTING)
1009 return 0;
1010
1011 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1012
1013 m->result = MOUNT_SUCCESS;
1014 m->reload_result = MOUNT_SUCCESS;
1015
1016 mount_enter_mounting(m);
1017 return 0;
1018 }
1019
1020 static int mount_stop(Unit *u) {
1021 Mount *m = MOUNT(u);
1022
1023 assert(m);
1024
1025 /* Already on it */
1026 if (m->state == MOUNT_UNMOUNTING ||
1027 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1028 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1029 m->state == MOUNT_MOUNTING_SIGTERM ||
1030 m->state == MOUNT_MOUNTING_SIGKILL)
1031 return 0;
1032
1033 assert(m->state == MOUNT_MOUNTING ||
1034 m->state == MOUNT_MOUNTING_DONE ||
1035 m->state == MOUNT_MOUNTED ||
1036 m->state == MOUNT_REMOUNTING ||
1037 m->state == MOUNT_REMOUNTING_SIGTERM ||
1038 m->state == MOUNT_REMOUNTING_SIGKILL);
1039
1040 mount_enter_unmounting(m);
1041 return 0;
1042 }
1043
1044 static int mount_reload(Unit *u) {
1045 Mount *m = MOUNT(u);
1046
1047 assert(m);
1048
1049 if (m->state == MOUNT_MOUNTING_DONE)
1050 return -EAGAIN;
1051
1052 assert(m->state == MOUNT_MOUNTED);
1053
1054 mount_enter_remounting(m);
1055 return 0;
1056 }
1057
1058 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1059 Mount *m = MOUNT(u);
1060
1061 assert(m);
1062 assert(f);
1063 assert(fds);
1064
1065 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1066 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1067 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1068
1069 if (m->control_pid > 0)
1070 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1071
1072 if (m->control_command_id >= 0)
1073 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1074
1075 return 0;
1076 }
1077
1078 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1079 Mount *m = MOUNT(u);
1080
1081 assert(u);
1082 assert(key);
1083 assert(value);
1084 assert(fds);
1085
1086 if (streq(key, "state")) {
1087 MountState state;
1088
1089 if ((state = mount_state_from_string(value)) < 0)
1090 log_unit_debug(u->id, "Failed to parse state value %s", value);
1091 else
1092 m->deserialized_state = state;
1093 } else if (streq(key, "result")) {
1094 MountResult f;
1095
1096 f = mount_result_from_string(value);
1097 if (f < 0)
1098 log_unit_debug(UNIT(m)->id,
1099 "Failed to parse result value %s", value);
1100 else if (f != MOUNT_SUCCESS)
1101 m->result = f;
1102
1103 } else if (streq(key, "reload-result")) {
1104 MountResult f;
1105
1106 f = mount_result_from_string(value);
1107 if (f < 0)
1108 log_unit_debug(UNIT(m)->id,
1109 "Failed to parse reload result value %s", value);
1110 else if (f != MOUNT_SUCCESS)
1111 m->reload_result = f;
1112
1113 } else if (streq(key, "control-pid")) {
1114 pid_t pid;
1115
1116 if (parse_pid(value, &pid) < 0)
1117 log_unit_debug(UNIT(m)->id,
1118 "Failed to parse control-pid value %s", value);
1119 else
1120 m->control_pid = pid;
1121 } else if (streq(key, "control-command")) {
1122 MountExecCommand id;
1123
1124 if ((id = mount_exec_command_from_string(value)) < 0)
1125 log_unit_debug(UNIT(m)->id,
1126 "Failed to parse exec-command value %s", value);
1127 else {
1128 m->control_command_id = id;
1129 m->control_command = m->exec_command + id;
1130 }
1131 } else
1132 log_unit_debug(UNIT(m)->id,
1133 "Unknown serialization key '%s'", key);
1134
1135 return 0;
1136 }
1137
1138 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1139 assert(u);
1140
1141 return state_translation_table[MOUNT(u)->state];
1142 }
1143
1144 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1145 assert(u);
1146
1147 return mount_state_to_string(MOUNT(u)->state);
1148 }
1149
1150 _pure_ static bool mount_check_gc(Unit *u) {
1151 Mount *m = MOUNT(u);
1152
1153 assert(m);
1154
1155 return m->from_proc_self_mountinfo;
1156 }
1157
1158 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1159 Mount *m = MOUNT(u);
1160 MountResult f;
1161
1162 assert(m);
1163 assert(pid >= 0);
1164
1165 if (pid != m->control_pid)
1166 return;
1167
1168 m->control_pid = 0;
1169
1170 if (is_clean_exit(code, status, NULL))
1171 f = MOUNT_SUCCESS;
1172 else if (code == CLD_EXITED)
1173 f = MOUNT_FAILURE_EXIT_CODE;
1174 else if (code == CLD_KILLED)
1175 f = MOUNT_FAILURE_SIGNAL;
1176 else if (code == CLD_DUMPED)
1177 f = MOUNT_FAILURE_CORE_DUMP;
1178 else
1179 assert_not_reached("Unknown code");
1180
1181 if (f != MOUNT_SUCCESS)
1182 m->result = f;
1183
1184 if (m->control_command) {
1185 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1186
1187 m->control_command = NULL;
1188 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1189 }
1190
1191 log_unit_full(u->id,
1192 f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1193 "%s mount process exited, code=%s status=%i",
1194 u->id, sigchld_code_to_string(code), status);
1195
1196 /* Note that mount(8) returning and the kernel sending us a
1197 * mount table change event might happen out-of-order. If an
1198 * operation succeed we assume the kernel will follow soon too
1199 * and already change into the resulting state. If it fails
1200 * we check if the kernel still knows about the mount. and
1201 * change state accordingly. */
1202
1203 switch (m->state) {
1204
1205 case MOUNT_MOUNTING:
1206 case MOUNT_MOUNTING_DONE:
1207 case MOUNT_MOUNTING_SIGKILL:
1208 case MOUNT_MOUNTING_SIGTERM:
1209
1210 if (f == MOUNT_SUCCESS)
1211 mount_enter_mounted(m, f);
1212 else if (m->from_proc_self_mountinfo)
1213 mount_enter_mounted(m, f);
1214 else
1215 mount_enter_dead(m, f);
1216 break;
1217
1218 case MOUNT_REMOUNTING:
1219 case MOUNT_REMOUNTING_SIGKILL:
1220 case MOUNT_REMOUNTING_SIGTERM:
1221
1222 m->reload_result = f;
1223 if (m->from_proc_self_mountinfo)
1224 mount_enter_mounted(m, MOUNT_SUCCESS);
1225 else
1226 mount_enter_dead(m, MOUNT_SUCCESS);
1227
1228 break;
1229
1230 case MOUNT_UNMOUNTING:
1231 case MOUNT_UNMOUNTING_SIGKILL:
1232 case MOUNT_UNMOUNTING_SIGTERM:
1233
1234 if (f == MOUNT_SUCCESS)
1235 mount_enter_dead(m, f);
1236 else if (m->from_proc_self_mountinfo)
1237 mount_enter_mounted(m, f);
1238 else
1239 mount_enter_dead(m, f);
1240 break;
1241
1242 default:
1243 assert_not_reached("Uh, control process died at wrong time.");
1244 }
1245
1246 /* Notify clients about changed exit status */
1247 unit_add_to_dbus_queue(u);
1248 }
1249
1250 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1251 Mount *m = MOUNT(userdata);
1252
1253 assert(m);
1254 assert(m->timer_event_source == source);
1255
1256 switch (m->state) {
1257
1258 case MOUNT_MOUNTING:
1259 case MOUNT_MOUNTING_DONE:
1260 log_unit_warning(UNIT(m)->id,
1261 "%s mounting timed out. Stopping.", UNIT(m)->id);
1262 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1263 break;
1264
1265 case MOUNT_REMOUNTING:
1266 log_unit_warning(UNIT(m)->id,
1267 "%s remounting timed out. Stopping.", UNIT(m)->id);
1268 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1269 mount_enter_mounted(m, MOUNT_SUCCESS);
1270 break;
1271
1272 case MOUNT_UNMOUNTING:
1273 log_unit_warning(UNIT(m)->id,
1274 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1275 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1276 break;
1277
1278 case MOUNT_MOUNTING_SIGTERM:
1279 if (m->kill_context.send_sigkill) {
1280 log_unit_warning(UNIT(m)->id,
1281 "%s mounting timed out. Killing.", UNIT(m)->id);
1282 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1283 } else {
1284 log_unit_warning(UNIT(m)->id,
1285 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1286 UNIT(m)->id);
1287
1288 if (m->from_proc_self_mountinfo)
1289 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1290 else
1291 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1292 }
1293 break;
1294
1295 case MOUNT_REMOUNTING_SIGTERM:
1296 if (m->kill_context.send_sigkill) {
1297 log_unit_warning(UNIT(m)->id,
1298 "%s remounting timed out. Killing.", UNIT(m)->id);
1299 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1300 } else {
1301 log_unit_warning(UNIT(m)->id,
1302 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1303 UNIT(m)->id);
1304
1305 if (m->from_proc_self_mountinfo)
1306 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1307 else
1308 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1309 }
1310 break;
1311
1312 case MOUNT_UNMOUNTING_SIGTERM:
1313 if (m->kill_context.send_sigkill) {
1314 log_unit_warning(UNIT(m)->id,
1315 "%s unmounting timed out. Killing.", UNIT(m)->id);
1316 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1317 } else {
1318 log_unit_warning(UNIT(m)->id,
1319 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1320 UNIT(m)->id);
1321
1322 if (m->from_proc_self_mountinfo)
1323 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1324 else
1325 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1326 }
1327 break;
1328
1329 case MOUNT_MOUNTING_SIGKILL:
1330 case MOUNT_REMOUNTING_SIGKILL:
1331 case MOUNT_UNMOUNTING_SIGKILL:
1332 log_unit_warning(UNIT(m)->id,
1333 "%s mount process still around after SIGKILL. Ignoring.",
1334 UNIT(m)->id);
1335
1336 if (m->from_proc_self_mountinfo)
1337 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1338 else
1339 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1340 break;
1341
1342 default:
1343 assert_not_reached("Timeout at wrong time.");
1344 }
1345
1346 return 0;
1347 }
1348
1349 static int mount_add_one(
1350 Manager *m,
1351 const char *what,
1352 const char *where,
1353 const char *options,
1354 const char *fstype,
1355 bool set_flags) {
1356
1357 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1358 bool load_extras = false;
1359 MountParameters *p;
1360 bool delete, changed = false;
1361 Unit *u;
1362 int r;
1363
1364 assert(m);
1365 assert(what);
1366 assert(where);
1367 assert(options);
1368 assert(fstype);
1369
1370 /* Ignore API mount points. They should never be referenced in
1371 * dependencies ever. */
1372 if (mount_point_is_api(where) || mount_point_ignore(where))
1373 return 0;
1374
1375 if (streq(fstype, "autofs"))
1376 return 0;
1377
1378 /* probably some kind of swap, ignore */
1379 if (!is_path(where))
1380 return 0;
1381
1382 e = unit_name_from_path(where, ".mount");
1383 if (!e)
1384 return -ENOMEM;
1385
1386 u = manager_get_unit(m, e);
1387 if (!u) {
1388 delete = true;
1389
1390 u = unit_new(m, sizeof(Mount));
1391 if (!u)
1392 return -ENOMEM;
1393
1394 r = unit_add_name(u, e);
1395 if (r < 0)
1396 goto fail;
1397
1398 MOUNT(u)->where = strdup(where);
1399 if (!MOUNT(u)->where) {
1400 r = -ENOMEM;
1401 goto fail;
1402 }
1403
1404 u->source_path = strdup("/proc/self/mountinfo");
1405 if (!u->source_path) {
1406 r = -ENOMEM;
1407 goto fail;
1408 }
1409
1410
1411 if (m->running_as == SYSTEMD_SYSTEM) {
1412 const char* target;
1413
1414 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1415
1416 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1417 if (r < 0)
1418 goto fail;
1419
1420 if (should_umount(MOUNT(u))) {
1421 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1422 if (r < 0)
1423 goto fail;
1424 }
1425 }
1426
1427 unit_add_to_load_queue(u);
1428 changed = true;
1429 } else {
1430 delete = false;
1431
1432 if (!MOUNT(u)->where) {
1433 MOUNT(u)->where = strdup(where);
1434 if (!MOUNT(u)->where) {
1435 r = -ENOMEM;
1436 goto fail;
1437 }
1438 }
1439
1440 if (u->load_state == UNIT_NOT_FOUND) {
1441 u->load_state = UNIT_LOADED;
1442 u->load_error = 0;
1443
1444 /* Load in the extras later on, after we
1445 * finished initialization of the unit */
1446 load_extras = true;
1447 changed = true;
1448 }
1449 }
1450
1451 w = strdup(what);
1452 o = strdup(options);
1453 f = strdup(fstype);
1454 if (!w || !o || !f) {
1455 r = -ENOMEM;
1456 goto fail;
1457 }
1458
1459 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1460
1461 changed = changed ||
1462 !streq_ptr(p->options, options) ||
1463 !streq_ptr(p->what, what) ||
1464 !streq_ptr(p->fstype, fstype);
1465
1466 if (set_flags) {
1467 MOUNT(u)->is_mounted = true;
1468 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1469 MOUNT(u)->just_changed = changed;
1470 }
1471
1472 MOUNT(u)->from_proc_self_mountinfo = true;
1473
1474 free(p->what);
1475 p->what = w;
1476 w = NULL;
1477
1478 free(p->options);
1479 p->options = o;
1480 o = NULL;
1481
1482 free(p->fstype);
1483 p->fstype = f;
1484 f = NULL;
1485
1486 if (load_extras) {
1487 r = mount_add_extras(MOUNT(u));
1488 if (r < 0)
1489 goto fail;
1490 }
1491
1492 if (changed)
1493 unit_add_to_dbus_queue(u);
1494
1495 return 0;
1496
1497 fail:
1498 if (delete && u)
1499 unit_free(u);
1500
1501 return r;
1502 }
1503
1504 static inline void mnt_free_table_p(struct libmnt_table **tb) {
1505 mnt_free_table(*tb);
1506 }
1507
1508 static inline void mnt_free_iter_p(struct libmnt_iter **itr) {
1509 mnt_free_iter(*itr);
1510 }
1511
1512 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1513 _cleanup_(mnt_free_table_p) struct libmnt_table *tb = NULL;
1514 _cleanup_(mnt_free_iter_p) struct libmnt_iter *itr = NULL;
1515 struct libmnt_fs *fs;
1516 int r = 0;
1517
1518 assert(m);
1519
1520 tb = mnt_new_table();
1521 itr = mnt_new_iter(MNT_ITER_FORWARD);
1522 if (!tb || !itr)
1523 return log_oom();
1524
1525 mnt_table_parse_mtab(tb, NULL);
1526 if (r)
1527 return r;
1528
1529 while (mnt_table_next_fs(tb, itr, &fs) == 0) {
1530 const char *device, *path, *options, *fstype;
1531 _cleanup_free_ const char *d = NULL, *p = NULL;
1532 int k;
1533
1534 device = mnt_fs_get_source(fs);
1535 path = mnt_fs_get_target(fs);
1536 options = mnt_fs_get_options(fs);
1537 fstype = mnt_fs_get_fstype(fs);
1538
1539 d = cunescape(device);
1540 p = cunescape(path);
1541 if (!d || !p)
1542 return log_oom();
1543
1544 k = mount_add_one(m, d, p, options, fstype, set_flags);
1545 if (k < 0)
1546 r = k;
1547 }
1548
1549 return r;
1550 }
1551
1552 static void mount_shutdown(Manager *m) {
1553 assert(m);
1554
1555 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1556
1557 if (m->proc_self_mountinfo) {
1558 fclose(m->proc_self_mountinfo);
1559 m->proc_self_mountinfo = NULL;
1560 }
1561 }
1562
1563 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1564 Mount *m = MOUNT(u);
1565 int r;
1566
1567 if (!m->timer_event_source)
1568 return 0;
1569
1570 r = sd_event_source_get_time(m->timer_event_source, timeout);
1571 if (r < 0)
1572 return r;
1573
1574 return 1;
1575 }
1576
1577 static int mount_enumerate(Manager *m) {
1578 int r;
1579 assert(m);
1580
1581 mnt_init_debug(0);
1582
1583 if (!m->proc_self_mountinfo) {
1584 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1585 if (!m->proc_self_mountinfo)
1586 return -errno;
1587
1588 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1589 if (r < 0)
1590 goto fail;
1591
1592 /* Dispatch this before we dispatch SIGCHLD, so that
1593 * we always get the events from /proc/self/mountinfo
1594 * before the SIGCHLD of /bin/mount. */
1595 r = sd_event_source_set_priority(m->mount_event_source, -10);
1596 if (r < 0)
1597 goto fail;
1598 }
1599
1600 r = mount_load_proc_self_mountinfo(m, false);
1601 if (r < 0)
1602 goto fail;
1603
1604 return 0;
1605
1606 fail:
1607 mount_shutdown(m);
1608 return r;
1609 }
1610
1611 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1612 Manager *m = userdata;
1613 Unit *u;
1614 int r;
1615
1616 assert(m);
1617 assert(revents & EPOLLPRI);
1618
1619 /* The manager calls this for every fd event happening on the
1620 * /proc/self/mountinfo file, which informs us about mounting
1621 * table changes */
1622
1623 r = mount_load_proc_self_mountinfo(m, true);
1624 if (r < 0) {
1625 log_error_errno(r, "Failed to reread /proc/self/mountinfo: %m");
1626
1627 /* Reset flags, just in case, for later calls */
1628 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1629 Mount *mount = MOUNT(u);
1630
1631 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1632 }
1633
1634 return 0;
1635 }
1636
1637 manager_dispatch_load_queue(m);
1638
1639 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1640 Mount *mount = MOUNT(u);
1641
1642 if (!mount->is_mounted) {
1643
1644 mount->from_proc_self_mountinfo = false;
1645
1646 switch (mount->state) {
1647
1648 case MOUNT_MOUNTED:
1649 /* This has just been unmounted by
1650 * somebody else, follow the state
1651 * change. */
1652 mount_enter_dead(mount, MOUNT_SUCCESS);
1653 break;
1654
1655 default:
1656 break;
1657 }
1658
1659 } else if (mount->just_mounted || mount->just_changed) {
1660
1661 /* New or changed mount entry */
1662
1663 switch (mount->state) {
1664
1665 case MOUNT_DEAD:
1666 case MOUNT_FAILED:
1667 /* This has just been mounted by
1668 * somebody else, follow the state
1669 * change. */
1670 mount_enter_mounted(mount, MOUNT_SUCCESS);
1671 break;
1672
1673 case MOUNT_MOUNTING:
1674 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1675 break;
1676
1677 default:
1678 /* Nothing really changed, but let's
1679 * issue an notification call
1680 * nonetheless, in case somebody is
1681 * waiting for this. (e.g. file system
1682 * ro/rw remounts.) */
1683 mount_set_state(mount, mount->state);
1684 break;
1685 }
1686 }
1687
1688 /* Reset the flags for later calls */
1689 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1690 }
1691
1692 return 0;
1693 }
1694
1695 static void mount_reset_failed(Unit *u) {
1696 Mount *m = MOUNT(u);
1697
1698 assert(m);
1699
1700 if (m->state == MOUNT_FAILED)
1701 mount_set_state(m, MOUNT_DEAD);
1702
1703 m->result = MOUNT_SUCCESS;
1704 m->reload_result = MOUNT_SUCCESS;
1705 }
1706
1707 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1708 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1709 }
1710
1711 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1712 [MOUNT_DEAD] = "dead",
1713 [MOUNT_MOUNTING] = "mounting",
1714 [MOUNT_MOUNTING_DONE] = "mounting-done",
1715 [MOUNT_MOUNTED] = "mounted",
1716 [MOUNT_REMOUNTING] = "remounting",
1717 [MOUNT_UNMOUNTING] = "unmounting",
1718 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1719 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1720 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1721 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1722 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1723 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1724 [MOUNT_FAILED] = "failed"
1725 };
1726
1727 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1728
1729 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1730 [MOUNT_EXEC_MOUNT] = "ExecMount",
1731 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1732 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1733 };
1734
1735 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1736
1737 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1738 [MOUNT_SUCCESS] = "success",
1739 [MOUNT_FAILURE_RESOURCES] = "resources",
1740 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1741 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1742 [MOUNT_FAILURE_SIGNAL] = "signal",
1743 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1744 };
1745
1746 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1747
1748 const UnitVTable mount_vtable = {
1749 .object_size = sizeof(Mount),
1750 .exec_context_offset = offsetof(Mount, exec_context),
1751 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1752 .kill_context_offset = offsetof(Mount, kill_context),
1753 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1754
1755 .sections =
1756 "Unit\0"
1757 "Mount\0"
1758 "Install\0",
1759 .private_section = "Mount",
1760
1761 .no_alias = true,
1762 .no_instances = true,
1763
1764 .init = mount_init,
1765 .load = mount_load,
1766 .done = mount_done,
1767
1768 .coldplug = mount_coldplug,
1769
1770 .dump = mount_dump,
1771
1772 .start = mount_start,
1773 .stop = mount_stop,
1774 .reload = mount_reload,
1775
1776 .kill = mount_kill,
1777
1778 .serialize = mount_serialize,
1779 .deserialize_item = mount_deserialize_item,
1780
1781 .active_state = mount_active_state,
1782 .sub_state_to_string = mount_sub_state_to_string,
1783
1784 .check_gc = mount_check_gc,
1785
1786 .sigchld_event = mount_sigchld_event,
1787
1788 .reset_failed = mount_reset_failed,
1789
1790 .bus_interface = "org.freedesktop.systemd1.Mount",
1791 .bus_vtable = bus_mount_vtable,
1792 .bus_set_property = bus_mount_set_property,
1793 .bus_commit_properties = bus_mount_commit_properties,
1794
1795 .get_timeout = mount_get_timeout,
1796
1797 .can_transient = true,
1798
1799 .enumerate = mount_enumerate,
1800 .shutdown = mount_shutdown,
1801
1802 .status_message_formats = {
1803 .starting_stopping = {
1804 [0] = "Mounting %s...",
1805 [1] = "Unmounting %s...",
1806 },
1807 .finished_start_job = {
1808 [JOB_DONE] = "Mounted %s.",
1809 [JOB_FAILED] = "Failed to mount %s.",
1810 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1811 [JOB_TIMEOUT] = "Timed out mounting %s.",
1812 },
1813 .finished_stop_job = {
1814 [JOB_DONE] = "Unmounted %s.",
1815 [JOB_FAILED] = "Failed unmounting %s.",
1816 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1817 },
1818 },
1819 };
Unnamed repository; edit this file 'description' to name the repository.