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