]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/core/mount.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
hostname-setup: also consider (Ε„one) an unset hostname
[thirdparty/systemd.git] / src / core / mount.c
... / ...
CommitLineData
1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
22#include <errno.h>
23#include <stdio.h>
24#include <mntent.h>
25#include <sys/epoll.h>
26#include <signal.h>
27
28#include "unit.h"
29#include "mount.h"
30#include "load-fragment.h"
31#include "load-dropin.h"
32#include "log.h"
33#include "strv.h"
34#include "mkdir.h"
35#include "path-util.h"
36#include "mount-setup.h"
37#include "unit-name.h"
38#include "dbus-mount.h"
39#include "special.h"
40#include "bus-errors.h"
41#include "exit-status.h"
42#include "def.h"
43
44static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
45 [MOUNT_DEAD] = UNIT_INACTIVE,
46 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
47 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
48 [MOUNT_MOUNTED] = UNIT_ACTIVE,
49 [MOUNT_REMOUNTING] = UNIT_RELOADING,
50 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
51 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
52 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
53 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
54 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
55 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
56 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
57 [MOUNT_FAILED] = UNIT_FAILED
58};
59
60static void mount_init(Unit *u) {
61 Mount *m = MOUNT(u);
62
63 assert(u);
64 assert(u->load_state == UNIT_STUB);
65
66 m->timeout_usec = DEFAULT_TIMEOUT_USEC;
67 m->directory_mode = 0755;
68
69 exec_context_init(&m->exec_context);
70
71 /* The stdio/kmsg bridge socket is on /, in order to avoid a
72 * dep loop, don't use kmsg logging for -.mount */
73 if (!unit_has_name(u, "-.mount")) {
74 m->exec_context.std_output = u->manager->default_std_output;
75 m->exec_context.std_error = u->manager->default_std_error;
76 }
77
78 /* We need to make sure that /bin/mount is always called in
79 * the same process group as us, so that the autofs kernel
80 * side doesn't send us another mount request while we are
81 * already trying to comply its last one. */
82 m->exec_context.same_pgrp = true;
83
84 m->timer_watch.type = WATCH_INVALID;
85
86 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
87
88 UNIT(m)->ignore_on_isolate = true;
89}
90
91static void mount_unwatch_control_pid(Mount *m) {
92 assert(m);
93
94 if (m->control_pid <= 0)
95 return;
96
97 unit_unwatch_pid(UNIT(m), m->control_pid);
98 m->control_pid = 0;
99}
100
101static void mount_parameters_done(MountParameters *p) {
102 assert(p);
103
104 free(p->what);
105 free(p->options);
106 free(p->fstype);
107
108 p->what = p->options = p->fstype = NULL;
109}
110
111static void mount_done(Unit *u) {
112 Mount *m = MOUNT(u);
113
114 assert(m);
115
116 free(m->where);
117 m->where = NULL;
118
119 mount_parameters_done(&m->parameters_etc_fstab);
120 mount_parameters_done(&m->parameters_proc_self_mountinfo);
121 mount_parameters_done(&m->parameters_fragment);
122
123 exec_context_done(&m->exec_context);
124 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
125 m->control_command = NULL;
126
127 mount_unwatch_control_pid(m);
128
129 unit_unwatch_timer(u, &m->timer_watch);
130}
131
132static MountParameters* get_mount_parameters_configured(Mount *m) {
133 assert(m);
134
135 if (m->from_fragment)
136 return &m->parameters_fragment;
137 else if (m->from_etc_fstab)
138 return &m->parameters_etc_fstab;
139
140 return NULL;
141}
142
143static MountParameters* get_mount_parameters(Mount *m) {
144 assert(m);
145
146 if (m->from_proc_self_mountinfo)
147 return &m->parameters_proc_self_mountinfo;
148
149 return get_mount_parameters_configured(m);
150}
151
152static int mount_add_mount_links(Mount *m) {
153 Unit *other;
154 int r;
155 MountParameters *pm;
156
157 assert(m);
158
159 pm = get_mount_parameters_configured(m);
160
161 /* Adds in links to other mount points that might lie below or
162 * above us in the hierarchy */
163
164 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
165 Mount *n = MOUNT(other);
166 MountParameters *pn;
167
168 if (n == m)
169 continue;
170
171 if (UNIT(n)->load_state != UNIT_LOADED)
172 continue;
173
174 pn = get_mount_parameters_configured(n);
175
176 if (path_startswith(m->where, n->where)) {
177
178 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
179 return r;
180
181 if (pn)
182 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
183 return r;
184
185 } else if (path_startswith(n->where, m->where)) {
186
187 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
188 return r;
189
190 if (pm)
191 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
192 return r;
193
194 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
195
196 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
197 return r;
198
199 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
200 return r;
201
202 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
203
204 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
205 return r;
206
207 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
208 return r;
209 }
210 }
211
212 return 0;
213}
214
215static int mount_add_swap_links(Mount *m) {
216 Unit *other;
217 int r;
218
219 assert(m);
220
221 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP])
222 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
223 return r;
224
225 return 0;
226}
227
228static int mount_add_path_links(Mount *m) {
229 Unit *other;
230 int r;
231
232 assert(m);
233
234 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
235 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
236 return r;
237
238 return 0;
239}
240
241static int mount_add_automount_links(Mount *m) {
242 Unit *other;
243 int r;
244
245 assert(m);
246
247 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
248 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
249 return r;
250
251 return 0;
252}
253
254static int mount_add_socket_links(Mount *m) {
255 Unit *other;
256 int r;
257
258 assert(m);
259
260 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
261 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
262 return r;
263
264 return 0;
265}
266
267static int mount_add_requires_mounts_links(Mount *m) {
268 Unit *other;
269 int r;
270
271 assert(m);
272
273 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
274 r = unit_add_one_mount_link(other, m);
275 if (r < 0)
276 return r;
277 }
278
279 return 0;
280}
281
282static char* mount_test_option(const char *haystack, const char *needle) {
283 struct mntent me;
284
285 assert(needle);
286
287 /* Like glibc's hasmntopt(), but works on a string, not a
288 * struct mntent */
289
290 if (!haystack)
291 return NULL;
292
293 zero(me);
294 me.mnt_opts = (char*) haystack;
295
296 return hasmntopt(&me, needle);
297}
298
299static bool mount_is_network(MountParameters *p) {
300 assert(p);
301
302 if (mount_test_option(p->options, "_netdev"))
303 return true;
304
305 if (p->fstype && fstype_is_network(p->fstype))
306 return true;
307
308 return false;
309}
310
311static bool mount_is_bind(MountParameters *p) {
312 assert(p);
313
314 if (mount_test_option(p->options, "bind"))
315 return true;
316
317 if (p->fstype && streq(p->fstype, "bind"))
318 return true;
319
320 return false;
321}
322
323static bool needs_quota(MountParameters *p) {
324 assert(p);
325
326 if (mount_is_network(p))
327 return false;
328
329 if (mount_is_bind(p))
330 return false;
331
332 return mount_test_option(p->options, "usrquota") ||
333 mount_test_option(p->options, "grpquota") ||
334 mount_test_option(p->options, "quota") ||
335 mount_test_option(p->options, "usrjquota") ||
336 mount_test_option(p->options, "grpjquota");
337}
338
339static int mount_add_fstab_links(Mount *m) {
340 const char *target, *after, *tu_wants = NULL;
341 MountParameters *p;
342 Unit *tu;
343 int r;
344 bool noauto, nofail, automount;
345
346 assert(m);
347
348 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
349 return 0;
350
351 if (!(p = get_mount_parameters_configured(m)))
352 return 0;
353
354 if (p != &m->parameters_etc_fstab)
355 return 0;
356
357 noauto = !!mount_test_option(p->options, "noauto");
358 nofail = !!mount_test_option(p->options, "nofail");
359 automount =
360 mount_test_option(p->options, "comment=systemd.automount") ||
361 mount_test_option(p->options, "x-systemd-automount");
362
363 if (mount_is_network(p)) {
364 target = SPECIAL_REMOTE_FS_TARGET;
365 after = tu_wants = SPECIAL_REMOTE_FS_PRE_TARGET;
366 } else {
367 target = SPECIAL_LOCAL_FS_TARGET;
368 after = SPECIAL_LOCAL_FS_PRE_TARGET;
369 }
370
371 r = manager_load_unit(UNIT(m)->manager, target, NULL, NULL, &tu);
372 if (r < 0)
373 return r;
374
375 if (tu_wants) {
376 r = unit_add_dependency_by_name(tu, UNIT_WANTS, tu_wants, NULL, true);
377 if (r < 0)
378 return r;
379 }
380
381 if (after) {
382 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
383 if (r < 0)
384 return r;
385 }
386
387 if (automount) {
388 Unit *am;
389
390 if ((r = unit_load_related_unit(UNIT(m), ".automount", &am)) < 0)
391 return r;
392
393 /* If auto is configured as well also pull in the
394 * mount right-away, but don't rely on it. */
395 if (!noauto) /* automount + auto */
396 if ((r = unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true)) < 0)
397 return r;
398
399 /* Install automount unit */
400 if (!nofail) /* automount + fail */
401 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, am, true);
402 else /* automount + nofail */
403 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_WANTS, am, true);
404
405 } else if (!noauto) {
406
407 /* Automatically add mount points that aren't natively
408 * configured to local-fs.target */
409
410 if (!nofail) /* auto + fail */
411 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
412 else /* auto + nofail */
413 return unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true);
414 }
415
416 return 0;
417}
418
419static int mount_add_device_links(Mount *m) {
420 MountParameters *p;
421 int r;
422
423 assert(m);
424
425 if (!(p = get_mount_parameters_configured(m)))
426 return 0;
427
428 if (!p->what)
429 return 0;
430
431 if (!mount_is_bind(p) &&
432 !path_equal(m->where, "/") &&
433 p == &m->parameters_etc_fstab) {
434 bool nofail, noauto;
435
436 noauto = !!mount_test_option(p->options, "noauto");
437 nofail = !!mount_test_option(p->options, "nofail");
438
439 if ((r = unit_add_node_link(UNIT(m), p->what,
440 !noauto && nofail &&
441 UNIT(m)->manager->running_as == MANAGER_SYSTEM)) < 0)
442 return r;
443 }
444
445 if (p->passno > 0 &&
446 !mount_is_bind(p) &&
447 UNIT(m)->manager->running_as == MANAGER_SYSTEM &&
448 !path_equal(m->where, "/")) {
449 char *name;
450 Unit *fsck;
451 /* Let's add in the fsck service */
452
453 /* aka SPECIAL_FSCK_SERVICE */
454 if (!(name = unit_name_from_path_instance("fsck", p->what, ".service")))
455 return -ENOMEM;
456
457 if ((r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck)) < 0) {
458 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
459 free(name);
460 return r;
461 }
462
463 free(name);
464
465 SERVICE(fsck)->fsck_passno = p->passno;
466
467 if ((r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true)) < 0)
468 return r;
469 }
470
471 return 0;
472}
473
474static int mount_add_default_dependencies(Mount *m) {
475 int r;
476 MountParameters *p;
477
478 assert(m);
479
480 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
481 return 0;
482
483 p = get_mount_parameters_configured(m);
484 if (p && needs_quota(p)) {
485 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true)) < 0 ||
486 (r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true)) < 0)
487 return r;
488 }
489
490 if (!path_equal(m->where, "/"))
491 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0)
492 return r;
493
494 return 0;
495}
496
497static int mount_fix_timeouts(Mount *m) {
498 MountParameters *p;
499 const char *timeout = NULL;
500 Unit *other;
501 Iterator i;
502 usec_t u;
503 char *t;
504 int r;
505
506 assert(m);
507
508 if (!(p = get_mount_parameters_configured(m)))
509 return 0;
510
511 /* Allow configuration how long we wait for a device that
512 * backs a mount point to show up. This is useful to support
513 * endless device timeouts for devices that show up only after
514 * user input, like crypto devices. */
515
516 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
517 timeout += 31;
518 else if ((timeout = mount_test_option(p->options, "x-systemd-device-timeout")))
519 timeout += 25;
520 else
521 return 0;
522
523 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
524 if (!t)
525 return -ENOMEM;
526
527 r = parse_usec(t, &u);
528 free(t);
529
530 if (r < 0) {
531 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
532 return r;
533 }
534
535 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
536 if (other->type != UNIT_DEVICE)
537 continue;
538
539 other->job_timeout = u;
540 }
541
542 return 0;
543}
544
545static int mount_verify(Mount *m) {
546 bool b;
547 char *e;
548 assert(m);
549
550 if (UNIT(m)->load_state != UNIT_LOADED)
551 return 0;
552
553 if (!m->from_etc_fstab && !m->from_fragment && !m->from_proc_self_mountinfo)
554 return -ENOENT;
555
556 if (!(e = unit_name_from_path(m->where, ".mount")))
557 return -ENOMEM;
558
559 b = unit_has_name(UNIT(m), e);
560 free(e);
561
562 if (!b) {
563 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
564 return -EINVAL;
565 }
566
567 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
568 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
569 return -EINVAL;
570 }
571
572 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
573 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
574 return -EBADMSG;
575 }
576
577 if (m->exec_context.pam_name && m->exec_context.kill_mode != KILL_CONTROL_GROUP) {
578 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
579 return -EINVAL;
580 }
581
582 return 0;
583}
584
585static int mount_load(Unit *u) {
586 Mount *m = MOUNT(u);
587 int r;
588
589 assert(u);
590 assert(u->load_state == UNIT_STUB);
591
592 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
593 return r;
594
595 /* This is a new unit? Then let's add in some extras */
596 if (u->load_state == UNIT_LOADED) {
597 if ((r = unit_add_exec_dependencies(u, &m->exec_context)) < 0)
598 return r;
599
600 if (UNIT(m)->fragment_path)
601 m->from_fragment = true;
602 else if (m->from_etc_fstab)
603 /* We always add several default dependencies to fstab mounts,
604 * but we do not want the implicit complementing of Wants= with After=
605 * in the target unit that this mount unit will be hooked into. */
606 UNIT(m)->default_dependencies = false;
607
608 if (!m->where)
609 if (!(m->where = unit_name_to_path(u->id)))
610 return -ENOMEM;
611
612 path_kill_slashes(m->where);
613
614 if (!UNIT(m)->description)
615 if ((r = unit_set_description(u, m->where)) < 0)
616 return r;
617
618 if ((r = mount_add_device_links(m)) < 0)
619 return r;
620
621 if ((r = mount_add_mount_links(m)) < 0)
622 return r;
623
624 if ((r = mount_add_socket_links(m)) < 0)
625 return r;
626
627 if ((r = mount_add_swap_links(m)) < 0)
628 return r;
629
630 if ((r = mount_add_path_links(m)) < 0)
631 return r;
632
633 r = mount_add_requires_mounts_links(m);
634 if (r < 0)
635 return r;
636
637 if ((r = mount_add_automount_links(m)) < 0)
638 return r;
639
640 if ((r = mount_add_fstab_links(m)) < 0)
641 return r;
642
643 if (UNIT(m)->default_dependencies || m->from_etc_fstab)
644 if ((r = mount_add_default_dependencies(m)) < 0)
645 return r;
646
647 if ((r = unit_add_default_cgroups(u)) < 0)
648 return r;
649
650 mount_fix_timeouts(m);
651 }
652
653 return mount_verify(m);
654}
655
656static int mount_notify_automount(Mount *m, int status) {
657 Unit *p;
658 int r;
659 Iterator i;
660
661 assert(m);
662
663 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
664 if (p->type == UNIT_AUTOMOUNT) {
665 r = automount_send_ready(AUTOMOUNT(p), status);
666 if (r < 0)
667 return r;
668 }
669
670 return 0;
671}
672
673static void mount_set_state(Mount *m, MountState state) {
674 MountState old_state;
675 assert(m);
676
677 old_state = m->state;
678 m->state = state;
679
680 if (state != MOUNT_MOUNTING &&
681 state != MOUNT_MOUNTING_DONE &&
682 state != MOUNT_REMOUNTING &&
683 state != MOUNT_UNMOUNTING &&
684 state != MOUNT_MOUNTING_SIGTERM &&
685 state != MOUNT_MOUNTING_SIGKILL &&
686 state != MOUNT_UNMOUNTING_SIGTERM &&
687 state != MOUNT_UNMOUNTING_SIGKILL &&
688 state != MOUNT_REMOUNTING_SIGTERM &&
689 state != MOUNT_REMOUNTING_SIGKILL) {
690 unit_unwatch_timer(UNIT(m), &m->timer_watch);
691 mount_unwatch_control_pid(m);
692 m->control_command = NULL;
693 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
694 }
695
696 if (state == MOUNT_MOUNTED ||
697 state == MOUNT_REMOUNTING)
698 mount_notify_automount(m, 0);
699 else if (state == MOUNT_DEAD ||
700 state == MOUNT_UNMOUNTING ||
701 state == MOUNT_MOUNTING_SIGTERM ||
702 state == MOUNT_MOUNTING_SIGKILL ||
703 state == MOUNT_REMOUNTING_SIGTERM ||
704 state == MOUNT_REMOUNTING_SIGKILL ||
705 state == MOUNT_UNMOUNTING_SIGTERM ||
706 state == MOUNT_UNMOUNTING_SIGKILL ||
707 state == MOUNT_FAILED)
708 mount_notify_automount(m, -ENODEV);
709
710 if (state != old_state)
711 log_debug("%s changed %s -> %s",
712 UNIT(m)->id,
713 mount_state_to_string(old_state),
714 mount_state_to_string(state));
715
716 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
717 m->reload_result = MOUNT_SUCCESS;
718}
719
720static int mount_coldplug(Unit *u) {
721 Mount *m = MOUNT(u);
722 MountState new_state = MOUNT_DEAD;
723 int r;
724
725 assert(m);
726 assert(m->state == MOUNT_DEAD);
727
728 if (m->deserialized_state != m->state)
729 new_state = m->deserialized_state;
730 else if (m->from_proc_self_mountinfo)
731 new_state = MOUNT_MOUNTED;
732
733 if (new_state != m->state) {
734
735 if (new_state == MOUNT_MOUNTING ||
736 new_state == MOUNT_MOUNTING_DONE ||
737 new_state == MOUNT_REMOUNTING ||
738 new_state == MOUNT_UNMOUNTING ||
739 new_state == MOUNT_MOUNTING_SIGTERM ||
740 new_state == MOUNT_MOUNTING_SIGKILL ||
741 new_state == MOUNT_UNMOUNTING_SIGTERM ||
742 new_state == MOUNT_UNMOUNTING_SIGKILL ||
743 new_state == MOUNT_REMOUNTING_SIGTERM ||
744 new_state == MOUNT_REMOUNTING_SIGKILL) {
745
746 if (m->control_pid <= 0)
747 return -EBADMSG;
748
749 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
750 return r;
751
752 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
753 return r;
754 }
755
756 mount_set_state(m, new_state);
757 }
758
759 return 0;
760}
761
762static void mount_dump(Unit *u, FILE *f, const char *prefix) {
763 Mount *m = MOUNT(u);
764 MountParameters *p;
765
766 assert(m);
767 assert(f);
768
769 p = get_mount_parameters(m);
770
771 fprintf(f,
772 "%sMount State: %s\n"
773 "%sResult: %s\n"
774 "%sWhere: %s\n"
775 "%sWhat: %s\n"
776 "%sFile System Type: %s\n"
777 "%sOptions: %s\n"
778 "%sFrom /etc/fstab: %s\n"
779 "%sFrom /proc/self/mountinfo: %s\n"
780 "%sFrom fragment: %s\n"
781 "%sDirectoryMode: %04o\n",
782 prefix, mount_state_to_string(m->state),
783 prefix, mount_result_to_string(m->result),
784 prefix, m->where,
785 prefix, strna(p->what),
786 prefix, strna(p->fstype),
787 prefix, strna(p->options),
788 prefix, yes_no(m->from_etc_fstab),
789 prefix, yes_no(m->from_proc_self_mountinfo),
790 prefix, yes_no(m->from_fragment),
791 prefix, m->directory_mode);
792
793 if (m->control_pid > 0)
794 fprintf(f,
795 "%sControl PID: %lu\n",
796 prefix, (unsigned long) m->control_pid);
797
798 exec_context_dump(&m->exec_context, f, prefix);
799}
800
801static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
802 pid_t pid;
803 int r;
804
805 assert(m);
806 assert(c);
807 assert(_pid);
808
809 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
810 goto fail;
811
812 if ((r = exec_spawn(c,
813 NULL,
814 &m->exec_context,
815 NULL, 0,
816 UNIT(m)->manager->environment,
817 true,
818 true,
819 true,
820 UNIT(m)->manager->confirm_spawn,
821 UNIT(m)->cgroup_bondings,
822 UNIT(m)->cgroup_attributes,
823 NULL,
824 NULL,
825 &pid)) < 0)
826 goto fail;
827
828 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
829 /* FIXME: we need to do something here */
830 goto fail;
831
832 *_pid = pid;
833
834 return 0;
835
836fail:
837 unit_unwatch_timer(UNIT(m), &m->timer_watch);
838
839 return r;
840}
841
842static void mount_enter_dead(Mount *m, MountResult f) {
843 assert(m);
844
845 if (f != MOUNT_SUCCESS)
846 m->result = f;
847
848 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
849}
850
851static void mount_enter_mounted(Mount *m, MountResult f) {
852 assert(m);
853
854 if (f != MOUNT_SUCCESS)
855 m->result = f;
856
857 mount_set_state(m, MOUNT_MOUNTED);
858}
859
860static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
861 int r;
862 Set *pid_set = NULL;
863 bool wait_for_exit = false;
864
865 assert(m);
866
867 if (f != MOUNT_SUCCESS)
868 m->result = f;
869
870 if (m->exec_context.kill_mode != KILL_NONE) {
871 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
872 state == MOUNT_UNMOUNTING_SIGTERM ||
873 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
874
875 if (m->control_pid > 0) {
876 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
877
878 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
879 else
880 wait_for_exit = true;
881 }
882
883 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
884
885 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
886 r = -ENOMEM;
887 goto fail;
888 }
889
890 /* Exclude the control pid from being killed via the cgroup */
891 if (m->control_pid > 0)
892 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
893 goto fail;
894
895 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
896 if (r < 0) {
897 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
898 log_warning("Failed to kill control group: %s", strerror(-r));
899 } else if (r > 0)
900 wait_for_exit = true;
901
902 set_free(pid_set);
903 pid_set = NULL;
904 }
905 }
906
907 if (wait_for_exit) {
908 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
909 goto fail;
910
911 mount_set_state(m, state);
912 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
913 mount_enter_mounted(m, MOUNT_SUCCESS);
914 else
915 mount_enter_dead(m, MOUNT_SUCCESS);
916
917 return;
918
919fail:
920 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
921
922 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
923 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
924 else
925 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
926
927 if (pid_set)
928 set_free(pid_set);
929}
930
931static void mount_enter_unmounting(Mount *m) {
932 int r;
933
934 assert(m);
935
936 m->control_command_id = MOUNT_EXEC_UNMOUNT;
937 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
938
939 if ((r = exec_command_set(
940 m->control_command,
941 "/bin/umount",
942 m->where,
943 NULL)) < 0)
944 goto fail;
945
946 mount_unwatch_control_pid(m);
947
948 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
949 goto fail;
950
951 mount_set_state(m, MOUNT_UNMOUNTING);
952
953 return;
954
955fail:
956 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
957 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
958}
959
960static void mount_enter_mounting(Mount *m) {
961 int r;
962 MountParameters *p;
963
964 assert(m);
965
966 m->control_command_id = MOUNT_EXEC_MOUNT;
967 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
968
969 mkdir_p(m->where, m->directory_mode);
970
971 /* Create the source directory for bind-mounts if needed */
972 p = get_mount_parameters_configured(m);
973 if (p && mount_is_bind(p))
974 mkdir_p(p->what, m->directory_mode);
975
976 if (m->from_fragment)
977 r = exec_command_set(
978 m->control_command,
979 "/bin/mount",
980 m->parameters_fragment.what,
981 m->where,
982 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
983 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
984 NULL);
985 else if (m->from_etc_fstab)
986 r = exec_command_set(
987 m->control_command,
988 "/bin/mount",
989 m->where,
990 NULL);
991 else
992 r = -ENOENT;
993
994 if (r < 0)
995 goto fail;
996
997 mount_unwatch_control_pid(m);
998
999 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1000 goto fail;
1001
1002 mount_set_state(m, MOUNT_MOUNTING);
1003
1004 return;
1005
1006fail:
1007 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
1008 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1009}
1010
1011static void mount_enter_mounting_done(Mount *m) {
1012 assert(m);
1013
1014 mount_set_state(m, MOUNT_MOUNTING_DONE);
1015}
1016
1017static void mount_enter_remounting(Mount *m) {
1018 int r;
1019
1020 assert(m);
1021
1022 m->control_command_id = MOUNT_EXEC_REMOUNT;
1023 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1024
1025 if (m->from_fragment) {
1026 char *buf = NULL;
1027 const char *o;
1028
1029 if (m->parameters_fragment.options) {
1030 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1031 r = -ENOMEM;
1032 goto fail;
1033 }
1034
1035 o = buf;
1036 } else
1037 o = "remount";
1038
1039 r = exec_command_set(
1040 m->control_command,
1041 "/bin/mount",
1042 m->parameters_fragment.what,
1043 m->where,
1044 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1045 "-o", o,
1046 NULL);
1047
1048 free(buf);
1049 } else if (m->from_etc_fstab)
1050 r = exec_command_set(
1051 m->control_command,
1052 "/bin/mount",
1053 m->where,
1054 "-o", "remount",
1055 NULL);
1056 else
1057 r = -ENOENT;
1058
1059 if (r < 0)
1060 goto fail;
1061
1062 mount_unwatch_control_pid(m);
1063
1064 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1065 goto fail;
1066
1067 mount_set_state(m, MOUNT_REMOUNTING);
1068
1069 return;
1070
1071fail:
1072 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1073 m->reload_result = MOUNT_FAILURE_RESOURCES;
1074 mount_enter_mounted(m, MOUNT_SUCCESS);
1075}
1076
1077static int mount_start(Unit *u) {
1078 Mount *m = MOUNT(u);
1079
1080 assert(m);
1081
1082 /* We cannot fulfill this request right now, try again later
1083 * please! */
1084 if (m->state == MOUNT_UNMOUNTING ||
1085 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1086 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1087 m->state == MOUNT_MOUNTING_SIGTERM ||
1088 m->state == MOUNT_MOUNTING_SIGKILL)
1089 return -EAGAIN;
1090
1091 /* Already on it! */
1092 if (m->state == MOUNT_MOUNTING)
1093 return 0;
1094
1095 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1096
1097 m->result = MOUNT_SUCCESS;
1098 m->reload_result = MOUNT_SUCCESS;
1099
1100 mount_enter_mounting(m);
1101 return 0;
1102}
1103
1104static int mount_stop(Unit *u) {
1105 Mount *m = MOUNT(u);
1106
1107 assert(m);
1108
1109 /* Already on it */
1110 if (m->state == MOUNT_UNMOUNTING ||
1111 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1112 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1113 m->state == MOUNT_MOUNTING_SIGTERM ||
1114 m->state == MOUNT_MOUNTING_SIGKILL)
1115 return 0;
1116
1117 assert(m->state == MOUNT_MOUNTING ||
1118 m->state == MOUNT_MOUNTING_DONE ||
1119 m->state == MOUNT_MOUNTED ||
1120 m->state == MOUNT_REMOUNTING ||
1121 m->state == MOUNT_REMOUNTING_SIGTERM ||
1122 m->state == MOUNT_REMOUNTING_SIGKILL);
1123
1124 mount_enter_unmounting(m);
1125 return 0;
1126}
1127
1128static int mount_reload(Unit *u) {
1129 Mount *m = MOUNT(u);
1130
1131 assert(m);
1132
1133 if (m->state == MOUNT_MOUNTING_DONE)
1134 return -EAGAIN;
1135
1136 assert(m->state == MOUNT_MOUNTED);
1137
1138 mount_enter_remounting(m);
1139 return 0;
1140}
1141
1142static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1143 Mount *m = MOUNT(u);
1144
1145 assert(m);
1146 assert(f);
1147 assert(fds);
1148
1149 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1150 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1151 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1152
1153 if (m->control_pid > 0)
1154 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1155
1156 if (m->control_command_id >= 0)
1157 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1158
1159 return 0;
1160}
1161
1162static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1163 Mount *m = MOUNT(u);
1164
1165 assert(u);
1166 assert(key);
1167 assert(value);
1168 assert(fds);
1169
1170 if (streq(key, "state")) {
1171 MountState state;
1172
1173 if ((state = mount_state_from_string(value)) < 0)
1174 log_debug("Failed to parse state value %s", value);
1175 else
1176 m->deserialized_state = state;
1177 } else if (streq(key, "result")) {
1178 MountResult f;
1179
1180 f = mount_result_from_string(value);
1181 if (f < 0)
1182 log_debug("Failed to parse result value %s", value);
1183 else if (f != MOUNT_SUCCESS)
1184 m->result = f;
1185
1186 } else if (streq(key, "reload-result")) {
1187 MountResult f;
1188
1189 f = mount_result_from_string(value);
1190 if (f < 0)
1191 log_debug("Failed to parse reload result value %s", value);
1192 else if (f != MOUNT_SUCCESS)
1193 m->reload_result = f;
1194
1195 } else if (streq(key, "control-pid")) {
1196 pid_t pid;
1197
1198 if (parse_pid(value, &pid) < 0)
1199 log_debug("Failed to parse control-pid value %s", value);
1200 else
1201 m->control_pid = pid;
1202 } else if (streq(key, "control-command")) {
1203 MountExecCommand id;
1204
1205 if ((id = mount_exec_command_from_string(value)) < 0)
1206 log_debug("Failed to parse exec-command value %s", value);
1207 else {
1208 m->control_command_id = id;
1209 m->control_command = m->exec_command + id;
1210 }
1211
1212 } else
1213 log_debug("Unknown serialization key '%s'", key);
1214
1215 return 0;
1216}
1217
1218static UnitActiveState mount_active_state(Unit *u) {
1219 assert(u);
1220
1221 return state_translation_table[MOUNT(u)->state];
1222}
1223
1224static const char *mount_sub_state_to_string(Unit *u) {
1225 assert(u);
1226
1227 return mount_state_to_string(MOUNT(u)->state);
1228}
1229
1230static bool mount_check_gc(Unit *u) {
1231 Mount *m = MOUNT(u);
1232
1233 assert(m);
1234
1235 return m->from_etc_fstab || m->from_proc_self_mountinfo;
1236}
1237
1238static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1239 Mount *m = MOUNT(u);
1240 MountResult f;
1241
1242 assert(m);
1243 assert(pid >= 0);
1244
1245 if (pid != m->control_pid)
1246 return;
1247
1248 m->control_pid = 0;
1249
1250 if (is_clean_exit(code, status))
1251 f = MOUNT_SUCCESS;
1252 else if (code == CLD_EXITED)
1253 f = MOUNT_FAILURE_EXIT_CODE;
1254 else if (code == CLD_KILLED)
1255 f = MOUNT_FAILURE_SIGNAL;
1256 else if (code == CLD_DUMPED)
1257 f = MOUNT_FAILURE_CORE_DUMP;
1258 else
1259 assert_not_reached("Unknown code");
1260
1261 if (f != MOUNT_SUCCESS)
1262 m->result = f;
1263
1264 if (m->control_command) {
1265 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1266
1267 m->control_command = NULL;
1268 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1269 }
1270
1271 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1272 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1273
1274 /* Note that mount(8) returning and the kernel sending us a
1275 * mount table change event might happen out-of-order. If an
1276 * operation succeed we assume the kernel will follow soon too
1277 * and already change into the resulting state. If it fails
1278 * we check if the kernel still knows about the mount. and
1279 * change state accordingly. */
1280
1281 switch (m->state) {
1282
1283 case MOUNT_MOUNTING:
1284 case MOUNT_MOUNTING_DONE:
1285 case MOUNT_MOUNTING_SIGKILL:
1286 case MOUNT_MOUNTING_SIGTERM:
1287
1288 if (f == MOUNT_SUCCESS)
1289 mount_enter_mounted(m, f);
1290 else if (m->from_proc_self_mountinfo)
1291 mount_enter_mounted(m, f);
1292 else
1293 mount_enter_dead(m, f);
1294 break;
1295
1296 case MOUNT_REMOUNTING:
1297 case MOUNT_REMOUNTING_SIGKILL:
1298 case MOUNT_REMOUNTING_SIGTERM:
1299
1300 m->reload_result = f;
1301 if (m->from_proc_self_mountinfo)
1302 mount_enter_mounted(m, MOUNT_SUCCESS);
1303 else
1304 mount_enter_dead(m, MOUNT_SUCCESS);
1305
1306 break;
1307
1308 case MOUNT_UNMOUNTING:
1309 case MOUNT_UNMOUNTING_SIGKILL:
1310 case MOUNT_UNMOUNTING_SIGTERM:
1311
1312 if (f == MOUNT_SUCCESS)
1313 mount_enter_dead(m, f);
1314 else if (m->from_proc_self_mountinfo)
1315 mount_enter_mounted(m, f);
1316 else
1317 mount_enter_dead(m, f);
1318 break;
1319
1320 default:
1321 assert_not_reached("Uh, control process died at wrong time.");
1322 }
1323
1324 /* Notify clients about changed exit status */
1325 unit_add_to_dbus_queue(u);
1326}
1327
1328static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1329 Mount *m = MOUNT(u);
1330
1331 assert(m);
1332 assert(elapsed == 1);
1333 assert(w == &m->timer_watch);
1334
1335 switch (m->state) {
1336
1337 case MOUNT_MOUNTING:
1338 case MOUNT_MOUNTING_DONE:
1339 log_warning("%s mounting timed out. Stopping.", u->id);
1340 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1341 break;
1342
1343 case MOUNT_REMOUNTING:
1344 log_warning("%s remounting timed out. Stopping.", u->id);
1345 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1346 mount_enter_mounted(m, MOUNT_SUCCESS);
1347 break;
1348
1349 case MOUNT_UNMOUNTING:
1350 log_warning("%s unmounting timed out. Stopping.", u->id);
1351 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1352 break;
1353
1354 case MOUNT_MOUNTING_SIGTERM:
1355 if (m->exec_context.send_sigkill) {
1356 log_warning("%s mounting timed out. Killing.", u->id);
1357 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1358 } else {
1359 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1360
1361 if (m->from_proc_self_mountinfo)
1362 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1363 else
1364 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1365 }
1366 break;
1367
1368 case MOUNT_REMOUNTING_SIGTERM:
1369 if (m->exec_context.send_sigkill) {
1370 log_warning("%s remounting timed out. Killing.", u->id);
1371 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1372 } else {
1373 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1374
1375 if (m->from_proc_self_mountinfo)
1376 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1377 else
1378 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1379 }
1380 break;
1381
1382 case MOUNT_UNMOUNTING_SIGTERM:
1383 if (m->exec_context.send_sigkill) {
1384 log_warning("%s unmounting timed out. Killing.", u->id);
1385 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1386 } else {
1387 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1388
1389 if (m->from_proc_self_mountinfo)
1390 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1391 else
1392 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1393 }
1394 break;
1395
1396 case MOUNT_MOUNTING_SIGKILL:
1397 case MOUNT_REMOUNTING_SIGKILL:
1398 case MOUNT_UNMOUNTING_SIGKILL:
1399 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1400
1401 if (m->from_proc_self_mountinfo)
1402 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1403 else
1404 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1405 break;
1406
1407 default:
1408 assert_not_reached("Timeout at wrong time.");
1409 }
1410}
1411
1412static int mount_add_one(
1413 Manager *m,
1414 const char *what,
1415 const char *where,
1416 const char *options,
1417 const char *fstype,
1418 int passno,
1419 bool from_proc_self_mountinfo,
1420 bool set_flags) {
1421 int r;
1422 Unit *u;
1423 bool delete;
1424 char *e, *w = NULL, *o = NULL, *f = NULL;
1425 MountParameters *p;
1426
1427 assert(m);
1428 assert(what);
1429 assert(where);
1430 assert(options);
1431 assert(fstype);
1432
1433 assert(!set_flags || from_proc_self_mountinfo);
1434
1435 /* Ignore API mount points. They should never be referenced in
1436 * dependencies ever. */
1437 if (mount_point_is_api(where) || mount_point_ignore(where))
1438 return 0;
1439
1440 if (streq(fstype, "autofs"))
1441 return 0;
1442
1443 /* probably some kind of swap, ignore */
1444 if (!is_path(where))
1445 return 0;
1446
1447 e = unit_name_from_path(where, ".mount");
1448 if (!e)
1449 return -ENOMEM;
1450
1451 u = manager_get_unit(m, e);
1452 if (!u) {
1453 delete = true;
1454
1455 u = unit_new(m, sizeof(Mount));
1456 if (!u) {
1457 free(e);
1458 return -ENOMEM;
1459 }
1460
1461 r = unit_add_name(u, e);
1462 free(e);
1463
1464 if (r < 0)
1465 goto fail;
1466
1467 MOUNT(u)->where = strdup(where);
1468 if (!MOUNT(u)->where) {
1469 r = -ENOMEM;
1470 goto fail;
1471 }
1472
1473 unit_add_to_load_queue(u);
1474 } else {
1475 delete = false;
1476 free(e);
1477 }
1478
1479 if (!(w = strdup(what)) ||
1480 !(o = strdup(options)) ||
1481 !(f = strdup(fstype))) {
1482 r = -ENOMEM;
1483 goto fail;
1484 }
1485
1486 if (from_proc_self_mountinfo) {
1487 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1488
1489 if (set_flags) {
1490 MOUNT(u)->is_mounted = true;
1491 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1492 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1493 }
1494
1495 MOUNT(u)->from_proc_self_mountinfo = true;
1496 } else {
1497 p = &MOUNT(u)->parameters_etc_fstab;
1498 MOUNT(u)->from_etc_fstab = true;
1499 }
1500
1501 free(p->what);
1502 p->what = w;
1503
1504 free(p->options);
1505 p->options = o;
1506
1507 free(p->fstype);
1508 p->fstype = f;
1509
1510 p->passno = passno;
1511
1512 unit_add_to_dbus_queue(u);
1513
1514 return 0;
1515
1516fail:
1517 free(w);
1518 free(o);
1519 free(f);
1520
1521 if (delete && u)
1522 unit_free(u);
1523
1524 return r;
1525}
1526
1527static int mount_find_pri(char *options) {
1528 char *end, *pri;
1529 unsigned long r;
1530
1531 if (!(pri = mount_test_option(options, "pri")))
1532 return 0;
1533
1534 pri += 4;
1535
1536 errno = 0;
1537 r = strtoul(pri, &end, 10);
1538
1539 if (errno != 0)
1540 return -errno;
1541
1542 if (end == pri || (*end != ',' && *end != 0))
1543 return -EINVAL;
1544
1545 return (int) r;
1546}
1547
1548static int mount_load_etc_fstab(Manager *m) {
1549 FILE *f;
1550 int r = 0;
1551 struct mntent* me;
1552
1553 assert(m);
1554
1555 errno = 0;
1556 f = setmntent("/etc/fstab", "r");
1557 if (!f)
1558 return errno == ENOENT ? 0 : -errno;
1559
1560 while ((me = getmntent(f))) {
1561 char *where, *what;
1562 int k;
1563
1564 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
1565 r = -ENOMEM;
1566 goto finish;
1567 }
1568
1569 if (!(where = strdup(me->mnt_dir))) {
1570 free(what);
1571 r = -ENOMEM;
1572 goto finish;
1573 }
1574
1575 if (what[0] == '/')
1576 path_kill_slashes(what);
1577
1578 if (where[0] == '/')
1579 path_kill_slashes(where);
1580
1581 if (streq(me->mnt_type, "swap")) {
1582 int pri;
1583
1584 if ((pri = mount_find_pri(me->mnt_opts)) < 0)
1585 k = pri;
1586 else
1587 k = swap_add_one(m,
1588 what,
1589 NULL,
1590 pri,
1591 !!mount_test_option(me->mnt_opts, "noauto"),
1592 !!mount_test_option(me->mnt_opts, "nofail"),
1593 false);
1594 } else
1595 k = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, me->mnt_passno, false, false);
1596
1597 free(what);
1598 free(where);
1599
1600 if (k < 0)
1601 r = k;
1602 }
1603
1604finish:
1605
1606 endmntent(f);
1607 return r;
1608}
1609
1610static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1611 int r = 0;
1612 unsigned i;
1613 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1614
1615 assert(m);
1616
1617 rewind(m->proc_self_mountinfo);
1618
1619 for (i = 1;; i++) {
1620 int k;
1621
1622 device = path = options = options2 = fstype = d = p = o = NULL;
1623
1624 if ((k = fscanf(m->proc_self_mountinfo,
1625 "%*s " /* (1) mount id */
1626 "%*s " /* (2) parent id */
1627 "%*s " /* (3) major:minor */
1628 "%*s " /* (4) root */
1629 "%ms " /* (5) mount point */
1630 "%ms" /* (6) mount options */
1631 "%*[^-]" /* (7) optional fields */
1632 "- " /* (8) separator */
1633 "%ms " /* (9) file system type */
1634 "%ms" /* (10) mount source */
1635 "%ms" /* (11) mount options 2 */
1636 "%*[^\n]", /* some rubbish at the end */
1637 &path,
1638 &options,
1639 &fstype,
1640 &device,
1641 &options2)) != 5) {
1642
1643 if (k == EOF)
1644 break;
1645
1646 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1647 goto clean_up;
1648 }
1649
1650 if (asprintf(&o, "%s,%s", options, options2) < 0) {
1651 r = -ENOMEM;
1652 goto finish;
1653 }
1654
1655 if (!(d = cunescape(device)) ||
1656 !(p = cunescape(path))) {
1657 r = -ENOMEM;
1658 goto finish;
1659 }
1660
1661 if ((k = mount_add_one(m, d, p, o, fstype, 0, true, set_flags)) < 0)
1662 r = k;
1663
1664clean_up:
1665 free(device);
1666 free(path);
1667 free(options);
1668 free(options2);
1669 free(fstype);
1670 free(d);
1671 free(p);
1672 free(o);
1673 }
1674
1675finish:
1676 free(device);
1677 free(path);
1678 free(options);
1679 free(options2);
1680 free(fstype);
1681 free(d);
1682 free(p);
1683 free(o);
1684
1685 return r;
1686}
1687
1688static void mount_shutdown(Manager *m) {
1689 assert(m);
1690
1691 if (m->proc_self_mountinfo) {
1692 fclose(m->proc_self_mountinfo);
1693 m->proc_self_mountinfo = NULL;
1694 }
1695}
1696
1697static int mount_enumerate(Manager *m) {
1698 int r;
1699 struct epoll_event ev;
1700 assert(m);
1701
1702 if (!m->proc_self_mountinfo) {
1703 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1704 return -errno;
1705
1706 m->mount_watch.type = WATCH_MOUNT;
1707 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1708
1709 zero(ev);
1710 ev.events = EPOLLPRI;
1711 ev.data.ptr = &m->mount_watch;
1712
1713 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1714 return -errno;
1715 }
1716
1717 if ((r = mount_load_etc_fstab(m)) < 0)
1718 goto fail;
1719
1720 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1721 goto fail;
1722
1723 return 0;
1724
1725fail:
1726 mount_shutdown(m);
1727 return r;
1728}
1729
1730void mount_fd_event(Manager *m, int events) {
1731 Unit *u;
1732 int r;
1733
1734 assert(m);
1735 assert(events & EPOLLPRI);
1736
1737 /* The manager calls this for every fd event happening on the
1738 * /proc/self/mountinfo file, which informs us about mounting
1739 * table changes */
1740
1741 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1742 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1743
1744 /* Reset flags, just in case, for later calls */
1745 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1746 Mount *mount = MOUNT(u);
1747
1748 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1749 }
1750
1751 return;
1752 }
1753
1754 manager_dispatch_load_queue(m);
1755
1756 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1757 Mount *mount = MOUNT(u);
1758
1759 if (!mount->is_mounted) {
1760 /* This has just been unmounted. */
1761
1762 mount->from_proc_self_mountinfo = false;
1763
1764 switch (mount->state) {
1765
1766 case MOUNT_MOUNTED:
1767 mount_enter_dead(mount, MOUNT_SUCCESS);
1768 break;
1769
1770 default:
1771 mount_set_state(mount, mount->state);
1772 break;
1773
1774 }
1775
1776 } else if (mount->just_mounted || mount->just_changed) {
1777
1778 /* New or changed mount entry */
1779
1780 switch (mount->state) {
1781
1782 case MOUNT_DEAD:
1783 case MOUNT_FAILED:
1784 mount_enter_mounted(mount, MOUNT_SUCCESS);
1785 break;
1786
1787 case MOUNT_MOUNTING:
1788 mount_enter_mounting_done(mount);
1789 break;
1790
1791 default:
1792 /* Nothing really changed, but let's
1793 * issue an notification call
1794 * nonetheless, in case somebody is
1795 * waiting for this. (e.g. file system
1796 * ro/rw remounts.) */
1797 mount_set_state(mount, mount->state);
1798 break;
1799 }
1800 }
1801
1802 /* Reset the flags for later calls */
1803 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1804 }
1805}
1806
1807static void mount_reset_failed(Unit *u) {
1808 Mount *m = MOUNT(u);
1809
1810 assert(m);
1811
1812 if (m->state == MOUNT_FAILED)
1813 mount_set_state(m, MOUNT_DEAD);
1814
1815 m->result = MOUNT_SUCCESS;
1816 m->reload_result = MOUNT_SUCCESS;
1817}
1818
1819static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1820 Mount *m = MOUNT(u);
1821 int r = 0;
1822 Set *pid_set = NULL;
1823
1824 assert(m);
1825
1826 if (who == KILL_MAIN) {
1827 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1828 return -ESRCH;
1829 }
1830
1831 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1832 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1833 return -ESRCH;
1834 }
1835
1836 if (who == KILL_CONTROL || who == KILL_ALL)
1837 if (m->control_pid > 0)
1838 if (kill(m->control_pid, signo) < 0)
1839 r = -errno;
1840
1841 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1842 int q;
1843
1844 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1845 return -ENOMEM;
1846
1847 /* Exclude the control pid from being killed via the cgroup */
1848 if (m->control_pid > 0)
1849 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1850 r = q;
1851 goto finish;
1852 }
1853
1854 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1855 if (q < 0)
1856 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1857 r = q;
1858 }
1859
1860finish:
1861 if (pid_set)
1862 set_free(pid_set);
1863
1864 return r;
1865}
1866
1867static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1868 [MOUNT_DEAD] = "dead",
1869 [MOUNT_MOUNTING] = "mounting",
1870 [MOUNT_MOUNTING_DONE] = "mounting-done",
1871 [MOUNT_MOUNTED] = "mounted",
1872 [MOUNT_REMOUNTING] = "remounting",
1873 [MOUNT_UNMOUNTING] = "unmounting",
1874 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1875 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1876 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1877 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1878 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1879 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1880 [MOUNT_FAILED] = "failed"
1881};
1882
1883DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1884
1885static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1886 [MOUNT_EXEC_MOUNT] = "ExecMount",
1887 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1888 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1889};
1890
1891DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1892
1893static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1894 [MOUNT_SUCCESS] = "success",
1895 [MOUNT_FAILURE_RESOURCES] = "resources",
1896 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1897 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1898 [MOUNT_FAILURE_SIGNAL] = "signal",
1899 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1900};
1901
1902DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1903
1904const UnitVTable mount_vtable = {
1905 .suffix = ".mount",
1906 .object_size = sizeof(Mount),
1907 .sections =
1908 "Unit\0"
1909 "Mount\0"
1910 "Install\0",
1911
1912 .no_alias = true,
1913 .no_instances = true,
1914
1915 .init = mount_init,
1916 .load = mount_load,
1917 .done = mount_done,
1918
1919 .coldplug = mount_coldplug,
1920
1921 .dump = mount_dump,
1922
1923 .start = mount_start,
1924 .stop = mount_stop,
1925 .reload = mount_reload,
1926
1927 .kill = mount_kill,
1928
1929 .serialize = mount_serialize,
1930 .deserialize_item = mount_deserialize_item,
1931
1932 .active_state = mount_active_state,
1933 .sub_state_to_string = mount_sub_state_to_string,
1934
1935 .check_gc = mount_check_gc,
1936
1937 .sigchld_event = mount_sigchld_event,
1938 .timer_event = mount_timer_event,
1939
1940 .reset_failed = mount_reset_failed,
1941
1942 .bus_interface = "org.freedesktop.systemd1.Mount",
1943 .bus_message_handler = bus_mount_message_handler,
1944 .bus_invalidating_properties = bus_mount_invalidating_properties,
1945
1946 .enumerate = mount_enumerate,
1947 .shutdown = mount_shutdown,
1948
1949 .status_message_formats = {
1950 .starting_stopping = {
1951 [0] = "Mounting %s...",
1952 [1] = "Unmounting %s...",
1953 },
1954 .finished_start_job = {
1955 [JOB_DONE] = "Mounted %s.",
1956 [JOB_FAILED] = "Failed to mount %s.",
1957 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1958 [JOB_TIMEOUT] = "Timed out mounting %s.",
1959 },
1960 .finished_stop_job = {
1961 [JOB_DONE] = "Unmounted %s.",
1962 [JOB_FAILED] = "Failed unmounting %s.",
1963 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1964 },
1965 },
1966};
Unnamed repository; edit this file 'description' to name the repository.