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