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