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