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