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