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