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