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