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