]> 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
readahead: minor code style fixes
[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("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 NULL,
774 &pid)) < 0)
775 goto fail;
776
777 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
778 /* FIXME: we need to do something here */
779 goto fail;
780
781 *_pid = pid;
782
783 return 0;
784
785 fail:
786 unit_unwatch_timer(UNIT(m), &m->timer_watch);
787
788 return r;
789 }
790
791 static void mount_enter_dead(Mount *m, MountResult f) {
792 assert(m);
793
794 if (f != MOUNT_SUCCESS)
795 m->result = f;
796
797 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
798 }
799
800 static void mount_enter_mounted(Mount *m, MountResult f) {
801 assert(m);
802
803 if (f != MOUNT_SUCCESS)
804 m->result = f;
805
806 mount_set_state(m, MOUNT_MOUNTED);
807 }
808
809 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
810 int r;
811 Set *pid_set = NULL;
812 bool wait_for_exit = false;
813
814 assert(m);
815
816 if (f != MOUNT_SUCCESS)
817 m->result = f;
818
819 if (m->exec_context.kill_mode != KILL_NONE) {
820 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
821 state == MOUNT_UNMOUNTING_SIGTERM ||
822 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
823
824 if (m->control_pid > 0) {
825 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
826
827 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
828 else
829 wait_for_exit = true;
830 }
831
832 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
833
834 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
835 r = -ENOMEM;
836 goto fail;
837 }
838
839 /* Exclude the control pid from being killed via the cgroup */
840 if (m->control_pid > 0)
841 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
842 goto fail;
843
844 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
845 if (r < 0) {
846 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
847 log_warning("Failed to kill control group: %s", strerror(-r));
848 } else if (r > 0)
849 wait_for_exit = true;
850
851 set_free(pid_set);
852 pid_set = NULL;
853 }
854 }
855
856 if (wait_for_exit) {
857 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
858 goto fail;
859
860 mount_set_state(m, state);
861 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
862 mount_enter_mounted(m, MOUNT_SUCCESS);
863 else
864 mount_enter_dead(m, MOUNT_SUCCESS);
865
866 return;
867
868 fail:
869 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
870
871 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
872 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
873 else
874 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
875
876 if (pid_set)
877 set_free(pid_set);
878 }
879
880 static void mount_enter_unmounting(Mount *m) {
881 int r;
882
883 assert(m);
884
885 m->control_command_id = MOUNT_EXEC_UNMOUNT;
886 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
887
888 if ((r = exec_command_set(
889 m->control_command,
890 "/bin/umount",
891 m->where,
892 NULL)) < 0)
893 goto fail;
894
895 mount_unwatch_control_pid(m);
896
897 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
898 goto fail;
899
900 mount_set_state(m, MOUNT_UNMOUNTING);
901
902 return;
903
904 fail:
905 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
906 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
907 }
908
909 static void mount_enter_mounting(Mount *m) {
910 int r;
911 MountParameters *p;
912
913 assert(m);
914
915 m->control_command_id = MOUNT_EXEC_MOUNT;
916 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
917
918 mkdir_p_label(m->where, m->directory_mode);
919
920 /* Create the source directory for bind-mounts if needed */
921 p = get_mount_parameters_fragment(m);
922 if (p && mount_is_bind(p))
923 mkdir_p_label(p->what, m->directory_mode);
924
925 if (m->from_fragment)
926 r = exec_command_set(
927 m->control_command,
928 "/bin/mount",
929 m->parameters_fragment.what,
930 m->where,
931 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
932 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
933 NULL);
934 else
935 r = -ENOENT;
936
937 if (r < 0)
938 goto fail;
939
940 mount_unwatch_control_pid(m);
941
942 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
943 goto fail;
944
945 mount_set_state(m, MOUNT_MOUNTING);
946
947 return;
948
949 fail:
950 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
951 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
952 }
953
954 static void mount_enter_mounting_done(Mount *m) {
955 assert(m);
956
957 mount_set_state(m, MOUNT_MOUNTING_DONE);
958 }
959
960 static void mount_enter_remounting(Mount *m) {
961 int r;
962
963 assert(m);
964
965 m->control_command_id = MOUNT_EXEC_REMOUNT;
966 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
967
968 if (m->from_fragment) {
969 char *buf = NULL;
970 const char *o;
971
972 if (m->parameters_fragment.options) {
973 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
974 r = -ENOMEM;
975 goto fail;
976 }
977
978 o = buf;
979 } else
980 o = "remount";
981
982 r = exec_command_set(
983 m->control_command,
984 "/bin/mount",
985 m->parameters_fragment.what,
986 m->where,
987 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
988 "-o", o,
989 NULL);
990
991 free(buf);
992 } else
993 r = -ENOENT;
994
995 if (r < 0)
996 goto fail;
997
998 mount_unwatch_control_pid(m);
999
1000 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1001 goto fail;
1002
1003 mount_set_state(m, MOUNT_REMOUNTING);
1004
1005 return;
1006
1007 fail:
1008 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1009 m->reload_result = MOUNT_FAILURE_RESOURCES;
1010 mount_enter_mounted(m, MOUNT_SUCCESS);
1011 }
1012
1013 static int mount_start(Unit *u) {
1014 Mount *m = MOUNT(u);
1015
1016 assert(m);
1017
1018 /* We cannot fulfill this request right now, try again later
1019 * please! */
1020 if (m->state == MOUNT_UNMOUNTING ||
1021 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1022 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1023 m->state == MOUNT_MOUNTING_SIGTERM ||
1024 m->state == MOUNT_MOUNTING_SIGKILL)
1025 return -EAGAIN;
1026
1027 /* Already on it! */
1028 if (m->state == MOUNT_MOUNTING)
1029 return 0;
1030
1031 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1032
1033 m->result = MOUNT_SUCCESS;
1034 m->reload_result = MOUNT_SUCCESS;
1035
1036 mount_enter_mounting(m);
1037 return 0;
1038 }
1039
1040 static int mount_stop(Unit *u) {
1041 Mount *m = MOUNT(u);
1042
1043 assert(m);
1044
1045 /* Already on it */
1046 if (m->state == MOUNT_UNMOUNTING ||
1047 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1048 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1049 m->state == MOUNT_MOUNTING_SIGTERM ||
1050 m->state == MOUNT_MOUNTING_SIGKILL)
1051 return 0;
1052
1053 assert(m->state == MOUNT_MOUNTING ||
1054 m->state == MOUNT_MOUNTING_DONE ||
1055 m->state == MOUNT_MOUNTED ||
1056 m->state == MOUNT_REMOUNTING ||
1057 m->state == MOUNT_REMOUNTING_SIGTERM ||
1058 m->state == MOUNT_REMOUNTING_SIGKILL);
1059
1060 mount_enter_unmounting(m);
1061 return 0;
1062 }
1063
1064 static int mount_reload(Unit *u) {
1065 Mount *m = MOUNT(u);
1066
1067 assert(m);
1068
1069 if (m->state == MOUNT_MOUNTING_DONE)
1070 return -EAGAIN;
1071
1072 assert(m->state == MOUNT_MOUNTED);
1073
1074 mount_enter_remounting(m);
1075 return 0;
1076 }
1077
1078 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1079 Mount *m = MOUNT(u);
1080
1081 assert(m);
1082 assert(f);
1083 assert(fds);
1084
1085 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1086 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1087 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1088
1089 if (m->control_pid > 0)
1090 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1091
1092 if (m->control_command_id >= 0)
1093 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1094
1095 return 0;
1096 }
1097
1098 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1099 Mount *m = MOUNT(u);
1100
1101 assert(u);
1102 assert(key);
1103 assert(value);
1104 assert(fds);
1105
1106 if (streq(key, "state")) {
1107 MountState state;
1108
1109 if ((state = mount_state_from_string(value)) < 0)
1110 log_debug("Failed to parse state value %s", value);
1111 else
1112 m->deserialized_state = state;
1113 } else if (streq(key, "result")) {
1114 MountResult f;
1115
1116 f = mount_result_from_string(value);
1117 if (f < 0)
1118 log_debug("Failed to parse result value %s", value);
1119 else if (f != MOUNT_SUCCESS)
1120 m->result = f;
1121
1122 } else if (streq(key, "reload-result")) {
1123 MountResult f;
1124
1125 f = mount_result_from_string(value);
1126 if (f < 0)
1127 log_debug("Failed to parse reload result value %s", value);
1128 else if (f != MOUNT_SUCCESS)
1129 m->reload_result = f;
1130
1131 } else if (streq(key, "control-pid")) {
1132 pid_t pid;
1133
1134 if (parse_pid(value, &pid) < 0)
1135 log_debug("Failed to parse control-pid value %s", value);
1136 else
1137 m->control_pid = pid;
1138 } else if (streq(key, "control-command")) {
1139 MountExecCommand id;
1140
1141 if ((id = mount_exec_command_from_string(value)) < 0)
1142 log_debug("Failed to parse exec-command value %s", value);
1143 else {
1144 m->control_command_id = id;
1145 m->control_command = m->exec_command + id;
1146 }
1147
1148 } else
1149 log_debug("Unknown serialization key '%s'", key);
1150
1151 return 0;
1152 }
1153
1154 static UnitActiveState mount_active_state(Unit *u) {
1155 assert(u);
1156
1157 return state_translation_table[MOUNT(u)->state];
1158 }
1159
1160 static const char *mount_sub_state_to_string(Unit *u) {
1161 assert(u);
1162
1163 return mount_state_to_string(MOUNT(u)->state);
1164 }
1165
1166 static bool mount_check_gc(Unit *u) {
1167 Mount *m = MOUNT(u);
1168
1169 assert(m);
1170
1171 return m->from_proc_self_mountinfo;
1172 }
1173
1174 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1175 Mount *m = MOUNT(u);
1176 MountResult f;
1177
1178 assert(m);
1179 assert(pid >= 0);
1180
1181 if (pid != m->control_pid)
1182 return;
1183
1184 m->control_pid = 0;
1185
1186 if (is_clean_exit(code, status))
1187 f = MOUNT_SUCCESS;
1188 else if (code == CLD_EXITED)
1189 f = MOUNT_FAILURE_EXIT_CODE;
1190 else if (code == CLD_KILLED)
1191 f = MOUNT_FAILURE_SIGNAL;
1192 else if (code == CLD_DUMPED)
1193 f = MOUNT_FAILURE_CORE_DUMP;
1194 else
1195 assert_not_reached("Unknown code");
1196
1197 if (f != MOUNT_SUCCESS)
1198 m->result = f;
1199
1200 if (m->control_command) {
1201 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1202
1203 m->control_command = NULL;
1204 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1205 }
1206
1207 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1208 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1209
1210 /* Note that mount(8) returning and the kernel sending us a
1211 * mount table change event might happen out-of-order. If an
1212 * operation succeed we assume the kernel will follow soon too
1213 * and already change into the resulting state. If it fails
1214 * we check if the kernel still knows about the mount. and
1215 * change state accordingly. */
1216
1217 switch (m->state) {
1218
1219 case MOUNT_MOUNTING:
1220 case MOUNT_MOUNTING_DONE:
1221 case MOUNT_MOUNTING_SIGKILL:
1222 case MOUNT_MOUNTING_SIGTERM:
1223
1224 if (f == MOUNT_SUCCESS)
1225 mount_enter_mounted(m, f);
1226 else if (m->from_proc_self_mountinfo)
1227 mount_enter_mounted(m, f);
1228 else
1229 mount_enter_dead(m, f);
1230 break;
1231
1232 case MOUNT_REMOUNTING:
1233 case MOUNT_REMOUNTING_SIGKILL:
1234 case MOUNT_REMOUNTING_SIGTERM:
1235
1236 m->reload_result = f;
1237 if (m->from_proc_self_mountinfo)
1238 mount_enter_mounted(m, MOUNT_SUCCESS);
1239 else
1240 mount_enter_dead(m, MOUNT_SUCCESS);
1241
1242 break;
1243
1244 case MOUNT_UNMOUNTING:
1245 case MOUNT_UNMOUNTING_SIGKILL:
1246 case MOUNT_UNMOUNTING_SIGTERM:
1247
1248 if (f == MOUNT_SUCCESS)
1249 mount_enter_dead(m, f);
1250 else if (m->from_proc_self_mountinfo)
1251 mount_enter_mounted(m, f);
1252 else
1253 mount_enter_dead(m, f);
1254 break;
1255
1256 default:
1257 assert_not_reached("Uh, control process died at wrong time.");
1258 }
1259
1260 /* Notify clients about changed exit status */
1261 unit_add_to_dbus_queue(u);
1262 }
1263
1264 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1265 Mount *m = MOUNT(u);
1266
1267 assert(m);
1268 assert(elapsed == 1);
1269 assert(w == &m->timer_watch);
1270
1271 switch (m->state) {
1272
1273 case MOUNT_MOUNTING:
1274 case MOUNT_MOUNTING_DONE:
1275 log_warning("%s mounting timed out. Stopping.", u->id);
1276 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1277 break;
1278
1279 case MOUNT_REMOUNTING:
1280 log_warning("%s remounting timed out. Stopping.", u->id);
1281 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1282 mount_enter_mounted(m, MOUNT_SUCCESS);
1283 break;
1284
1285 case MOUNT_UNMOUNTING:
1286 log_warning("%s unmounting timed out. Stopping.", u->id);
1287 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1288 break;
1289
1290 case MOUNT_MOUNTING_SIGTERM:
1291 if (m->exec_context.send_sigkill) {
1292 log_warning("%s mounting timed out. Killing.", u->id);
1293 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1294 } else {
1295 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1296
1297 if (m->from_proc_self_mountinfo)
1298 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1299 else
1300 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1301 }
1302 break;
1303
1304 case MOUNT_REMOUNTING_SIGTERM:
1305 if (m->exec_context.send_sigkill) {
1306 log_warning("%s remounting timed out. Killing.", u->id);
1307 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1308 } else {
1309 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1310
1311 if (m->from_proc_self_mountinfo)
1312 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1313 else
1314 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1315 }
1316 break;
1317
1318 case MOUNT_UNMOUNTING_SIGTERM:
1319 if (m->exec_context.send_sigkill) {
1320 log_warning("%s unmounting timed out. Killing.", u->id);
1321 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1322 } else {
1323 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1324
1325 if (m->from_proc_self_mountinfo)
1326 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1327 else
1328 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1329 }
1330 break;
1331
1332 case MOUNT_MOUNTING_SIGKILL:
1333 case MOUNT_REMOUNTING_SIGKILL:
1334 case MOUNT_UNMOUNTING_SIGKILL:
1335 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1336
1337 if (m->from_proc_self_mountinfo)
1338 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1339 else
1340 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1341 break;
1342
1343 default:
1344 assert_not_reached("Timeout at wrong time.");
1345 }
1346 }
1347
1348 static int mount_add_one(
1349 Manager *m,
1350 const char *what,
1351 const char *where,
1352 const char *options,
1353 const char *fstype,
1354 int passno,
1355 bool set_flags) {
1356 int r;
1357 Unit *u;
1358 bool delete;
1359 char *e, *w = NULL, *o = NULL, *f = NULL;
1360 MountParameters *p;
1361
1362 assert(m);
1363 assert(what);
1364 assert(where);
1365 assert(options);
1366 assert(fstype);
1367
1368 /* Ignore API mount points. They should never be referenced in
1369 * dependencies ever. */
1370 if (mount_point_is_api(where) || mount_point_ignore(where))
1371 return 0;
1372
1373 if (streq(fstype, "autofs"))
1374 return 0;
1375
1376 /* probably some kind of swap, ignore */
1377 if (!is_path(where))
1378 return 0;
1379
1380 e = unit_name_from_path(where, ".mount");
1381 if (!e)
1382 return -ENOMEM;
1383
1384 u = manager_get_unit(m, e);
1385 if (!u) {
1386 delete = true;
1387
1388 u = unit_new(m, sizeof(Mount));
1389 if (!u) {
1390 free(e);
1391 return -ENOMEM;
1392 }
1393
1394 r = unit_add_name(u, e);
1395 free(e);
1396
1397 if (r < 0)
1398 goto fail;
1399
1400 MOUNT(u)->where = strdup(where);
1401 if (!MOUNT(u)->where) {
1402 r = -ENOMEM;
1403 goto fail;
1404 }
1405
1406 unit_add_to_load_queue(u);
1407 } else {
1408 delete = false;
1409 free(e);
1410 }
1411
1412 if (!(w = strdup(what)) ||
1413 !(o = strdup(options)) ||
1414 !(f = strdup(fstype))) {
1415 r = -ENOMEM;
1416 goto fail;
1417 }
1418
1419 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1420 if (set_flags) {
1421 MOUNT(u)->is_mounted = true;
1422 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1423 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1424 }
1425
1426 MOUNT(u)->from_proc_self_mountinfo = true;
1427
1428 free(p->what);
1429 p->what = w;
1430
1431 free(p->options);
1432 p->options = o;
1433
1434 free(p->fstype);
1435 p->fstype = f;
1436
1437 p->passno = passno;
1438
1439 unit_add_to_dbus_queue(u);
1440
1441 return 0;
1442
1443 fail:
1444 free(w);
1445 free(o);
1446 free(f);
1447
1448 if (delete && u)
1449 unit_free(u);
1450
1451 return r;
1452 }
1453
1454 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1455 int r = 0;
1456 unsigned i;
1457 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1458
1459 assert(m);
1460
1461 rewind(m->proc_self_mountinfo);
1462
1463 for (i = 1;; i++) {
1464 int k;
1465
1466 device = path = options = options2 = fstype = d = p = o = NULL;
1467
1468 if ((k = fscanf(m->proc_self_mountinfo,
1469 "%*s " /* (1) mount id */
1470 "%*s " /* (2) parent id */
1471 "%*s " /* (3) major:minor */
1472 "%*s " /* (4) root */
1473 "%ms " /* (5) mount point */
1474 "%ms" /* (6) mount options */
1475 "%*[^-]" /* (7) optional fields */
1476 "- " /* (8) separator */
1477 "%ms " /* (9) file system type */
1478 "%ms" /* (10) mount source */
1479 "%ms" /* (11) mount options 2 */
1480 "%*[^\n]", /* some rubbish at the end */
1481 &path,
1482 &options,
1483 &fstype,
1484 &device,
1485 &options2)) != 5) {
1486
1487 if (k == EOF)
1488 break;
1489
1490 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1491 goto clean_up;
1492 }
1493
1494 o = join(options, ",", options2, NULL);
1495 if (!o) {
1496 r = -ENOMEM;
1497 goto finish;
1498 }
1499
1500 if (!(d = cunescape(device)) ||
1501 !(p = cunescape(path))) {
1502 r = -ENOMEM;
1503 goto finish;
1504 }
1505
1506 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1507 r = k;
1508
1509 clean_up:
1510 free(device);
1511 free(path);
1512 free(options);
1513 free(options2);
1514 free(fstype);
1515 free(d);
1516 free(p);
1517 free(o);
1518 }
1519
1520 finish:
1521 free(device);
1522 free(path);
1523 free(options);
1524 free(options2);
1525 free(fstype);
1526 free(d);
1527 free(p);
1528 free(o);
1529
1530 return r;
1531 }
1532
1533 static void mount_shutdown(Manager *m) {
1534 assert(m);
1535
1536 if (m->proc_self_mountinfo) {
1537 fclose(m->proc_self_mountinfo);
1538 m->proc_self_mountinfo = NULL;
1539 }
1540 }
1541
1542 static int mount_enumerate(Manager *m) {
1543 int r;
1544 struct epoll_event ev;
1545 assert(m);
1546
1547 if (!m->proc_self_mountinfo) {
1548 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1549 return -errno;
1550
1551 m->mount_watch.type = WATCH_MOUNT;
1552 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1553
1554 zero(ev);
1555 ev.events = EPOLLPRI;
1556 ev.data.ptr = &m->mount_watch;
1557
1558 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1559 return -errno;
1560 }
1561
1562 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1563 goto fail;
1564
1565 return 0;
1566
1567 fail:
1568 mount_shutdown(m);
1569 return r;
1570 }
1571
1572 void mount_fd_event(Manager *m, int events) {
1573 Unit *u;
1574 int r;
1575
1576 assert(m);
1577 assert(events & EPOLLPRI);
1578
1579 /* The manager calls this for every fd event happening on the
1580 * /proc/self/mountinfo file, which informs us about mounting
1581 * table changes */
1582
1583 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1584 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1585
1586 /* Reset flags, just in case, for later calls */
1587 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1588 Mount *mount = MOUNT(u);
1589
1590 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1591 }
1592
1593 return;
1594 }
1595
1596 manager_dispatch_load_queue(m);
1597
1598 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1599 Mount *mount = MOUNT(u);
1600
1601 if (!mount->is_mounted) {
1602 /* This has just been unmounted. */
1603
1604 mount->from_proc_self_mountinfo = false;
1605
1606 switch (mount->state) {
1607
1608 case MOUNT_MOUNTED:
1609 mount_enter_dead(mount, MOUNT_SUCCESS);
1610 break;
1611
1612 default:
1613 mount_set_state(mount, mount->state);
1614 break;
1615
1616 }
1617
1618 } else if (mount->just_mounted || mount->just_changed) {
1619
1620 /* New or changed mount entry */
1621
1622 switch (mount->state) {
1623
1624 case MOUNT_DEAD:
1625 case MOUNT_FAILED:
1626 mount_enter_mounted(mount, MOUNT_SUCCESS);
1627 break;
1628
1629 case MOUNT_MOUNTING:
1630 mount_enter_mounting_done(mount);
1631 break;
1632
1633 default:
1634 /* Nothing really changed, but let's
1635 * issue an notification call
1636 * nonetheless, in case somebody is
1637 * waiting for this. (e.g. file system
1638 * ro/rw remounts.) */
1639 mount_set_state(mount, mount->state);
1640 break;
1641 }
1642 }
1643
1644 /* Reset the flags for later calls */
1645 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1646 }
1647 }
1648
1649 static void mount_reset_failed(Unit *u) {
1650 Mount *m = MOUNT(u);
1651
1652 assert(m);
1653
1654 if (m->state == MOUNT_FAILED)
1655 mount_set_state(m, MOUNT_DEAD);
1656
1657 m->result = MOUNT_SUCCESS;
1658 m->reload_result = MOUNT_SUCCESS;
1659 }
1660
1661 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1662 Mount *m = MOUNT(u);
1663 int r = 0;
1664 Set *pid_set = NULL;
1665
1666 assert(m);
1667
1668 if (who == KILL_MAIN) {
1669 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1670 return -ESRCH;
1671 }
1672
1673 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1674 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1675 return -ESRCH;
1676 }
1677
1678 if (who == KILL_CONTROL || who == KILL_ALL)
1679 if (m->control_pid > 0)
1680 if (kill(m->control_pid, signo) < 0)
1681 r = -errno;
1682
1683 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1684 int q;
1685
1686 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1687 return -ENOMEM;
1688
1689 /* Exclude the control pid from being killed via the cgroup */
1690 if (m->control_pid > 0)
1691 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1692 r = q;
1693 goto finish;
1694 }
1695
1696 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1697 if (q < 0)
1698 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1699 r = q;
1700 }
1701
1702 finish:
1703 if (pid_set)
1704 set_free(pid_set);
1705
1706 return r;
1707 }
1708
1709 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1710 [MOUNT_DEAD] = "dead",
1711 [MOUNT_MOUNTING] = "mounting",
1712 [MOUNT_MOUNTING_DONE] = "mounting-done",
1713 [MOUNT_MOUNTED] = "mounted",
1714 [MOUNT_REMOUNTING] = "remounting",
1715 [MOUNT_UNMOUNTING] = "unmounting",
1716 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1717 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1718 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1719 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1720 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1721 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1722 [MOUNT_FAILED] = "failed"
1723 };
1724
1725 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1726
1727 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1728 [MOUNT_EXEC_MOUNT] = "ExecMount",
1729 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1730 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1731 };
1732
1733 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1734
1735 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1736 [MOUNT_SUCCESS] = "success",
1737 [MOUNT_FAILURE_RESOURCES] = "resources",
1738 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1739 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1740 [MOUNT_FAILURE_SIGNAL] = "signal",
1741 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1742 };
1743
1744 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1745
1746 const UnitVTable mount_vtable = {
1747 .suffix = ".mount",
1748 .object_size = sizeof(Mount),
1749 .sections =
1750 "Unit\0"
1751 "Mount\0"
1752 "Install\0",
1753
1754 .no_alias = true,
1755 .no_instances = true,
1756
1757 .init = mount_init,
1758 .load = mount_load,
1759 .done = mount_done,
1760
1761 .coldplug = mount_coldplug,
1762
1763 .dump = mount_dump,
1764
1765 .start = mount_start,
1766 .stop = mount_stop,
1767 .reload = mount_reload,
1768
1769 .kill = mount_kill,
1770
1771 .serialize = mount_serialize,
1772 .deserialize_item = mount_deserialize_item,
1773
1774 .active_state = mount_active_state,
1775 .sub_state_to_string = mount_sub_state_to_string,
1776
1777 .check_gc = mount_check_gc,
1778
1779 .sigchld_event = mount_sigchld_event,
1780 .timer_event = mount_timer_event,
1781
1782 .reset_failed = mount_reset_failed,
1783
1784 .bus_interface = "org.freedesktop.systemd1.Mount",
1785 .bus_message_handler = bus_mount_message_handler,
1786 .bus_invalidating_properties = bus_mount_invalidating_properties,
1787
1788 .enumerate = mount_enumerate,
1789 .shutdown = mount_shutdown,
1790
1791 .status_message_formats = {
1792 .starting_stopping = {
1793 [0] = "Mounting %s...",
1794 [1] = "Unmounting %s...",
1795 },
1796 .finished_start_job = {
1797 [JOB_DONE] = "Mounted %s.",
1798 [JOB_FAILED] = "Failed to mount %s.",
1799 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1800 [JOB_TIMEOUT] = "Timed out mounting %s.",
1801 },
1802 .finished_stop_job = {
1803 [JOB_DONE] = "Unmounted %s.",
1804 [JOB_FAILED] = "Failed unmounting %s.",
1805 [JOB_TIMEOUT] = "Timed out unmounting %s.",
1806 },
1807 },
1808 };
Unnamed repository; edit this file 'description' to name the repository.