2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2010-02-03 13:03:47 +01:00
|
|
|
|
2010-01-23 01:52:57 +01:00
|
|
|
#include <errno.h>
|
2015-10-23 18:52:53 +02:00
|
|
|
#include <signal.h>
|
2010-01-29 02:07:41 +01:00
|
|
|
#include <stdio.h>
|
2010-01-29 06:04:08 +01:00
|
|
|
#include <sys/epoll.h>
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2018-03-26 17:34:53 +02:00
|
|
|
#include <libmount.h>
|
|
|
|
|
2012-12-05 11:59:05 +01:00
|
|
|
#include "sd-messages.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2010-04-18 03:08:16 +02:00
|
|
|
#include "dbus-mount.h"
|
2018-05-15 20:17:34 +02:00
|
|
|
#include "device.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "escape.h"
|
2011-01-20 18:22:03 +01:00
|
|
|
#include "exit-status.h"
|
2016-11-07 16:14:59 +01:00
|
|
|
#include "format-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "fstab-util.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "manager.h"
|
|
|
|
#include "mkdir.h"
|
|
|
|
#include "mount-setup.h"
|
2015-10-27 13:45:00 +01:00
|
|
|
#include "mount-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "mount.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "path-util.h"
|
2015-10-27 14:24:58 +01:00
|
|
|
#include "process-util.h"
|
2018-10-17 20:40:09 +02:00
|
|
|
#include "serialize.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "special.h"
|
2015-10-26 22:31:05 +01:00
|
|
|
#include "string-table.h"
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "string-util.h"
|
2015-10-23 18:52:53 +02:00
|
|
|
#include "strv.h"
|
|
|
|
#include "unit-name.h"
|
|
|
|
#include "unit.h"
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2014-12-12 20:12:35 +01:00
|
|
|
#define RETRY_UMOUNT_MAX 32
|
|
|
|
|
2014-11-28 23:04:24 +01:00
|
|
|
DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
|
|
|
|
DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
|
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
|
|
|
|
[MOUNT_DEAD] = UNIT_INACTIVE,
|
|
|
|
[MOUNT_MOUNTING] = UNIT_ACTIVATING,
|
2018-01-20 21:12:09 +01:00
|
|
|
[MOUNT_MOUNTING_DONE] = UNIT_ACTIVATING,
|
2010-01-29 03:18:09 +01:00
|
|
|
[MOUNT_MOUNTED] = UNIT_ACTIVE,
|
2010-07-01 03:34:15 +02:00
|
|
|
[MOUNT_REMOUNTING] = UNIT_RELOADING,
|
2010-01-29 03:18:09 +01:00
|
|
|
[MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
|
2010-07-01 03:34:15 +02:00
|
|
|
[MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
|
|
|
|
[MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
|
2010-04-10 17:53:17 +02:00
|
|
|
[MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
|
|
|
|
[MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
|
2010-08-31 00:23:34 +02:00
|
|
|
[MOUNT_FAILED] = UNIT_FAILED
|
2010-01-29 03:18:09 +01:00
|
|
|
};
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
|
|
|
|
static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
|
2017-09-25 19:25:50 +02:00
|
|
|
static bool MOUNT_STATE_WITH_PROCESS(MountState state) {
|
|
|
|
return IN_SET(state,
|
|
|
|
MOUNT_MOUNTING,
|
|
|
|
MOUNT_MOUNTING_DONE,
|
|
|
|
MOUNT_REMOUNTING,
|
|
|
|
MOUNT_REMOUNTING_SIGTERM,
|
|
|
|
MOUNT_REMOUNTING_SIGKILL,
|
|
|
|
MOUNT_UNMOUNTING,
|
|
|
|
MOUNT_UNMOUNTING_SIGTERM,
|
|
|
|
MOUNT_UNMOUNTING_SIGKILL);
|
|
|
|
}
|
|
|
|
|
2014-11-24 05:33:38 +01:00
|
|
|
static bool mount_needs_network(const char *options, const char *fstype) {
|
2015-01-09 22:58:29 +01:00
|
|
|
if (fstab_test_option(options, "_netdev\0"))
|
2013-10-05 19:09:43 +02:00
|
|
|
return true;
|
|
|
|
|
2014-11-24 05:33:38 +01:00
|
|
|
if (fstype && fstype_is_network(fstype))
|
2013-10-05 19:09:43 +02:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-11-28 20:22:47 +01:00
|
|
|
static bool mount_is_network(const MountParameters *p) {
|
2014-11-24 05:33:38 +01:00
|
|
|
assert(p);
|
|
|
|
|
|
|
|
return mount_needs_network(p->options, p->fstype);
|
|
|
|
}
|
|
|
|
|
2016-04-25 13:25:00 +02:00
|
|
|
static bool mount_is_loop(const MountParameters *p) {
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
if (fstab_test_option(p->options, "loop\0"))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-11-28 20:22:47 +01:00
|
|
|
static bool mount_is_bind(const MountParameters *p) {
|
2013-10-05 19:09:43 +02:00
|
|
|
assert(p);
|
|
|
|
|
2015-01-09 22:58:29 +01:00
|
|
|
if (fstab_test_option(p->options, "bind\0" "rbind\0"))
|
2013-10-05 19:09:43 +02:00
|
|
|
return true;
|
|
|
|
|
2015-01-09 22:58:29 +01:00
|
|
|
if (p->fstype && STR_IN_SET(p->fstype, "bind", "rbind"))
|
2013-10-05 19:09:43 +02:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-11-28 20:22:47 +01:00
|
|
|
static bool mount_is_auto(const MountParameters *p) {
|
2013-10-05 19:09:43 +02:00
|
|
|
assert(p);
|
|
|
|
|
2015-01-09 22:58:29 +01:00
|
|
|
return !fstab_test_option(p->options, "noauto\0");
|
2013-10-05 19:09:43 +02:00
|
|
|
}
|
|
|
|
|
fstab-generator: fix automount option and don't start associated mount unit at boot
Without this patch applied the mount unit with 'automount' option was still
pulled by local-fs.target and thus was activated during the boot process which
defeats the purpose of the 'automount' option:
$ grep /mnt /etc/fstab
/dev/vdb1 /mnt ext2 defaults,x-systemd.automount 0 0
$ reboot
...
$ mount | grep mnt
systemd-1 on /mnt type autofs (rw,relatime,fd=34,pgrp=1,timeout=0,minproto=5,maxproto=5,direct)
/dev/vdb1 on /mnt type ext2 (rw,relatime)
$ systemctl status mnt.mount | grep Active
Active: active (mounted) since Thu 2016-03-03 21:36:22 CET; 42s ago
With the patch applied:
$ reboot
...
$ mount | grep mnt
systemd-1 on /mnt type autofs (rw,relatime,fd=22,pgrp=1,timeout=0,minproto=5,maxproto=5,direct)
$ systemctl status mnt.mount | grep Active
Active: inactive (dead)
$ ls /mnt
lost+found
$ systemctl status mnt.mount | grep Active
Active: active (mounted) since Thu 2016-03-03 21:47:32 CET; 4s ago
2015-12-01 18:01:44 +01:00
|
|
|
static bool mount_is_automount(const MountParameters *p) {
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
return fstab_test_option(p->options,
|
|
|
|
"comment=systemd.automount\0"
|
|
|
|
"x-systemd.automount\0");
|
|
|
|
}
|
|
|
|
|
2016-12-16 17:13:58 +01:00
|
|
|
static bool mount_is_bound_to_device(const Mount *m) {
|
|
|
|
const MountParameters *p;
|
|
|
|
|
|
|
|
if (m->from_fragment)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
p = &m->parameters_proc_self_mountinfo;
|
|
|
|
return fstab_test_option(p->options, "x-systemd.device-bound\0");
|
|
|
|
}
|
|
|
|
|
2014-11-28 20:22:47 +01:00
|
|
|
static bool needs_quota(const MountParameters *p) {
|
2013-10-05 19:09:43 +02:00
|
|
|
assert(p);
|
|
|
|
|
2015-03-30 14:42:02 +02:00
|
|
|
/* Quotas are not enabled on network filesystems,
|
2015-04-01 13:08:25 +02:00
|
|
|
* but we want them, for example, on storage connected via iscsi */
|
2015-03-30 14:42:02 +02:00
|
|
|
if (p->fstype && fstype_is_network(p->fstype))
|
2013-10-05 19:09:43 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (mount_is_bind(p))
|
|
|
|
return false;
|
|
|
|
|
2015-01-09 22:58:29 +01:00
|
|
|
return fstab_test_option(p->options,
|
|
|
|
"usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
|
2013-10-05 19:09:43 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static void mount_init(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2013-11-04 17:47:43 +01:00
|
|
|
m->timeout_usec = u->manager->default_timeout_start_usec;
|
2018-01-13 13:30:43 +01:00
|
|
|
|
|
|
|
m->exec_context.std_output = u->manager->default_std_output;
|
|
|
|
m->exec_context.std_error = u->manager->default_std_error;
|
|
|
|
|
2010-07-02 00:28:44 +02:00
|
|
|
m->directory_mode = 0755;
|
|
|
|
|
2015-05-13 15:43:04 +02:00
|
|
|
/* We need to make sure that /usr/bin/mount is always called
|
|
|
|
* in the same process group as us, so that the autofs kernel
|
2010-04-21 03:27:44 +02:00
|
|
|
* side doesn't send us another mount request while we are
|
|
|
|
* already trying to comply its last one. */
|
2010-07-05 01:08:13 +02:00
|
|
|
m->exec_context.same_pgrp = true;
|
2010-04-16 23:24:39 +02:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
|
2011-04-14 03:55:03 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
u->ignore_on_isolate = true;
|
2010-04-16 23:24:39 +02:00
|
|
|
}
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
static int mount_arm_timer(Mount *m, usec_t usec) {
|
2013-11-19 21:12:59 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->timer_event_source) {
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = sd_event_source_set_time(m->timer_event_source, usec);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
|
|
|
|
}
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
if (usec == USEC_INFINITY)
|
|
|
|
return 0;
|
|
|
|
|
2015-04-29 16:05:32 +02:00
|
|
|
r = sd_event_add_time(
|
2014-03-24 02:49:09 +01:00
|
|
|
UNIT(m)->manager->event,
|
|
|
|
&m->timer_event_source,
|
|
|
|
CLOCK_MONOTONIC,
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
usec, 0,
|
2014-03-24 02:49:09 +01:00
|
|
|
mount_dispatch_timer, m);
|
2015-04-29 16:05:32 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
(void) sd_event_source_set_description(m->timer_event_source, "mount-timer");
|
|
|
|
|
|
|
|
return 0;
|
2013-11-19 21:12:59 +01:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static void mount_unwatch_control_pid(Mount *m) {
|
2010-04-11 00:22:36 +02:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->control_pid <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
unit_unwatch_pid(UNIT(m), m->control_pid);
|
|
|
|
m->control_pid = 0;
|
|
|
|
}
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
static void mount_parameters_done(MountParameters *p) {
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
free(p->what);
|
|
|
|
free(p->options);
|
|
|
|
free(p->fstype);
|
|
|
|
|
|
|
|
p->what = p->options = p->fstype = NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
static void mount_done(Unit *u) {
|
2010-01-29 06:04:08 +01:00
|
|
|
Mount *m = MOUNT(u);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-01-29 06:04:08 +01:00
|
|
|
assert(m);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2015-09-08 18:43:11 +02:00
|
|
|
m->where = mfree(m->where);
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
mount_parameters_done(&m->parameters_proc_self_mountinfo);
|
|
|
|
mount_parameters_done(&m->parameters_fragment);
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
m->exec_runtime = exec_runtime_unref(m->exec_runtime, false);
|
2010-04-10 17:53:17 +02:00
|
|
|
exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
|
|
|
|
m->control_command = NULL;
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_unref(&m->dynamic_creds);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
mount_unwatch_control_pid(m);
|
2010-01-29 03:18:09 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->timer_event_source = sd_event_source_unref(m->timer_event_source);
|
2010-01-29 03:18:09 +01:00
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
|
2011-03-30 01:53:34 +02:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->from_fragment)
|
|
|
|
return &m->parameters_fragment;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static MountParameters* get_mount_parameters(Mount *m) {
|
2011-03-30 01:53:34 +02:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
|
|
|
return &m->parameters_proc_self_mountinfo;
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
return get_mount_parameters_fragment(m);
|
2011-03-30 01:53:34 +02:00
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int mount_add_mount_dependencies(Mount *m) {
|
2010-09-28 01:03:19 +02:00
|
|
|
MountParameters *pm;
|
2012-01-15 12:04:08 +01:00
|
|
|
Unit *other;
|
2013-09-26 20:14:24 +02:00
|
|
|
Iterator i;
|
|
|
|
Set *s;
|
2010-01-29 02:07:41 +01:00
|
|
|
int r;
|
|
|
|
|
2010-05-13 03:07:16 +02:00
|
|
|
assert(m);
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (!path_equal(m->where, "/")) {
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
_cleanup_free_ char *parent = NULL;
|
|
|
|
|
|
|
|
/* Adds in links to other mount points that might lie further up in the hierarchy */
|
2015-10-26 17:30:56 +01:00
|
|
|
|
|
|
|
parent = dirname_malloc(m->where);
|
|
|
|
if (!parent)
|
|
|
|
return -ENOMEM;
|
2010-05-24 05:25:33 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_require_mounts_for(UNIT(m), parent, UNIT_DEPENDENCY_IMPLICIT);
|
2013-01-04 21:29:48 +01:00
|
|
|
if (r < 0)
|
2010-05-24 05:25:33 +02:00
|
|
|
return r;
|
2013-01-04 21:29:48 +01:00
|
|
|
}
|
2010-05-24 05:25:33 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
/* Adds in dependencies to other mount points that might be needed for the source path (if this is a bind mount
|
|
|
|
* or a loop mount) to be available. */
|
2013-09-26 20:14:24 +02:00
|
|
|
pm = get_mount_parameters_fragment(m);
|
2013-10-05 19:09:43 +02:00
|
|
|
if (pm && pm->what &&
|
|
|
|
path_is_absolute(pm->what) &&
|
2016-04-25 13:25:00 +02:00
|
|
|
(mount_is_bind(pm) || mount_is_loop(pm) || !mount_is_network(pm))) {
|
2013-10-05 19:09:43 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_require_mounts_for(UNIT(m), pm->what, UNIT_DEPENDENCY_FILE);
|
2013-01-04 21:29:48 +01:00
|
|
|
if (r < 0)
|
2010-05-13 03:07:16 +02:00
|
|
|
return r;
|
2013-01-04 21:29:48 +01:00
|
|
|
}
|
2010-01-29 02:07:41 +01:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
/* Adds in dependencies to other units that use this path or paths further down in the hierarchy */
|
2013-09-26 20:14:24 +02:00
|
|
|
s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
|
|
|
|
SET_FOREACH(other, s, i) {
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (other->load_state != UNIT_LOADED)
|
|
|
|
continue;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (other == UNIT(m))
|
|
|
|
continue;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true, UNIT_DEPENDENCY_PATH);
|
2013-01-04 21:29:48 +01:00
|
|
|
if (r < 0)
|
2010-05-13 03:07:16 +02:00
|
|
|
return r;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (UNIT(m)->fragment_path) {
|
|
|
|
/* If we have fragment configuration, then make this dependency required */
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true, UNIT_DEPENDENCY_PATH);
|
2013-09-26 20:14:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2012-04-29 14:26:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int mount_add_device_dependencies(Mount *m) {
|
2013-08-19 11:45:24 +02:00
|
|
|
bool device_wants_mount = false;
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
UnitDependencyMask mask;
|
|
|
|
MountParameters *p;
|
2016-12-16 17:13:58 +01:00
|
|
|
UnitDependency dep;
|
2010-10-13 03:57:04 +02:00
|
|
|
int r;
|
2010-08-25 20:37:04 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2015-01-28 13:53:25 +01:00
|
|
|
p = get_mount_parameters(m);
|
2012-05-22 19:23:33 +02:00
|
|
|
if (!p)
|
2010-08-25 20:37:04 +02:00
|
|
|
return 0;
|
|
|
|
|
2010-10-13 03:57:04 +02:00
|
|
|
if (!p->what)
|
2010-08-25 20:37:04 +02:00
|
|
|
return 0;
|
2010-09-28 01:03:19 +02:00
|
|
|
|
2012-09-24 12:48:46 +02:00
|
|
|
if (mount_is_bind(p))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!is_device_path(p->what))
|
|
|
|
return 0;
|
|
|
|
|
2015-05-13 14:40:37 +02:00
|
|
|
/* /dev/root is a really weird thing, it's not a real device,
|
|
|
|
* but just a path the kernel exports for the root file system
|
|
|
|
* specified on the kernel command line. Ignore it here. */
|
|
|
|
if (path_equal(p->what, "/dev/root"))
|
|
|
|
return 0;
|
|
|
|
|
2012-09-24 12:48:46 +02:00
|
|
|
if (path_equal(m->where, "/"))
|
|
|
|
return 0;
|
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (mount_is_auto(p) && !mount_is_automount(p) && MANAGER_IS_SYSTEM(UNIT(m)->manager))
|
2013-08-19 11:45:24 +02:00
|
|
|
device_wants_mount = true;
|
|
|
|
|
2016-12-16 17:13:58 +01:00
|
|
|
/* Mount units from /proc/self/mountinfo are not bound to devices
|
|
|
|
* by default since they're subject to races when devices are
|
|
|
|
* unplugged. But the user can still force this dep with an
|
|
|
|
* appropriate option (or udev property) so the mount units are
|
|
|
|
* automatically stopped when the device disappears suddenly. */
|
|
|
|
dep = mount_is_bound_to_device(m) ? UNIT_BINDS_TO : UNIT_REQUIRES;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
|
|
|
|
|
|
|
|
r = unit_add_node_dependency(UNIT(m), p->what, device_wants_mount, dep, mask);
|
2012-09-24 12:48:46 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-13 03:57:04 +02:00
|
|
|
|
|
|
|
return 0;
|
2010-08-25 20:37:04 +02:00
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int mount_add_quota_dependencies(Mount *m) {
|
|
|
|
UnitDependencyMask mask;
|
2012-05-22 19:23:33 +02:00
|
|
|
MountParameters *p;
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
int r;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (!MANAGER_IS_SYSTEM(UNIT(m)->manager))
|
2012-05-22 19:23:33 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
p = get_mount_parameters_fragment(m);
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!needs_quota(p))
|
|
|
|
return 0;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT;
|
|
|
|
|
2018-09-15 20:02:00 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, true, mask);
|
2012-05-22 19:23:33 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2018-09-15 20:02:00 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, true, mask);
|
2012-05-22 19:23:33 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
static bool mount_is_extrinsic(Mount *m) {
|
2013-08-19 06:34:13 +02:00
|
|
|
MountParameters *p;
|
2016-11-29 22:50:21 +01:00
|
|
|
assert(m);
|
2013-08-19 06:34:13 +02:00
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
/* Returns true for all units that are "magic" and should be excluded from the usual start-up and shutdown
|
|
|
|
* dependencies. We call them "extrinsic" here, as they are generally mounted outside of the systemd dependency
|
|
|
|
* logic. We shouldn't attempt to manage them ourselves but it's fine if the user operates on them with us. */
|
|
|
|
|
|
|
|
if (!MANAGER_IS_SYSTEM(UNIT(m)->manager)) /* We only automatically manage mounts if we are in system mode */
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (PATH_IN_SET(m->where, /* Don't bother with the OS data itself */
|
|
|
|
"/",
|
|
|
|
"/usr"))
|
|
|
|
return true;
|
2013-08-19 06:34:13 +02:00
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
if (PATH_STARTSWITH_SET(m->where,
|
|
|
|
"/run/initramfs", /* This should stay around from before we boot until after we shutdown */
|
|
|
|
"/proc", /* All of this is API VFS */
|
|
|
|
"/sys", /* … dito … */
|
|
|
|
"/dev")) /* … dito … */
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* If this is an initrd mount, and we are not in the initrd, then leave this around forever, too. */
|
2013-08-19 06:34:13 +02:00
|
|
|
p = get_mount_parameters(m);
|
2016-11-29 22:50:21 +01:00
|
|
|
if (p && fstab_test_option(p->options, "x-initrd.mount\0") && !in_initrd())
|
|
|
|
return true;
|
2013-08-19 06:34:13 +02:00
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
return false;
|
2013-08-19 06:34:13 +02:00
|
|
|
}
|
|
|
|
|
2010-07-12 22:55:27 +02:00
|
|
|
static int mount_add_default_dependencies(Mount *m) {
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
UnitDependencyMask mask;
|
|
|
|
int r;
|
2012-01-13 23:55:28 +01:00
|
|
|
MountParameters *p;
|
2015-11-11 20:46:09 +01:00
|
|
|
const char *after;
|
2010-07-12 22:55:27 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
if (!UNIT(m)->default_dependencies)
|
|
|
|
return 0;
|
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
/* We do not add any default dependencies to /, /usr or /run/initramfs/, since they are guaranteed to stay
|
|
|
|
* mounted the whole time, since our system is on it. Also, don't bother with anything mounted below virtual
|
|
|
|
* file systems, it's also going to be virtual, and hence not worth the effort. */
|
|
|
|
if (mount_is_extrinsic(m))
|
2012-05-22 19:23:33 +02:00
|
|
|
return 0;
|
2010-07-12 22:55:27 +02:00
|
|
|
|
2015-01-23 13:44:44 +01:00
|
|
|
p = get_mount_parameters(m);
|
|
|
|
if (!p)
|
2012-05-22 19:23:33 +02:00
|
|
|
return 0;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
mask = m->from_fragment ? UNIT_DEPENDENCY_FILE : UNIT_DEPENDENCY_MOUNTINFO_DEFAULT;
|
|
|
|
|
2013-03-25 22:04:40 +01:00
|
|
|
if (mount_is_network(p)) {
|
2015-11-11 20:46:09 +01:00
|
|
|
/* We order ourselves after network.target. This is
|
|
|
|
* primarily useful at shutdown: services that take
|
|
|
|
* down the network should order themselves before
|
|
|
|
* network.target, so that they are shut down only
|
|
|
|
* after this mount unit is stopped. */
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_NETWORK_TARGET, true, mask);
|
2013-03-27 02:51:33 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-11-11 20:46:09 +01:00
|
|
|
/* We pull in network-online.target, and order
|
|
|
|
* ourselves after it. This is useful at start-up to
|
|
|
|
* actively pull in tools that want to be started
|
|
|
|
* before we start mounting network file systems, and
|
|
|
|
* whose purpose it is to delay this until the network
|
|
|
|
* is "up". */
|
|
|
|
|
2018-09-15 20:02:00 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, SPECIAL_NETWORK_ONLINE_TARGET, true, mask);
|
2013-03-25 22:04:40 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2015-11-11 20:46:09 +01:00
|
|
|
|
|
|
|
after = SPECIAL_REMOTE_FS_PRE_TARGET;
|
|
|
|
} else
|
|
|
|
after = SPECIAL_LOCAL_FS_PRE_TARGET;
|
|
|
|
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, true, mask);
|
2015-11-11 20:46:09 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-03-25 22:04:40 +01:00
|
|
|
|
2018-09-15 20:02:00 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, true, mask);
|
2016-11-29 22:50:21 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-07-12 22:55:27 +02:00
|
|
|
|
2017-10-26 17:24:55 +02:00
|
|
|
/* If this is a tmpfs mount then we have to unmount it before we try to deactivate swaps */
|
2017-11-12 14:25:58 +01:00
|
|
|
if (streq_ptr(p->fstype, "tmpfs")) {
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_SWAP_TARGET, true, mask);
|
2017-10-26 17:24:55 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2010-07-12 22:55:27 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
static int mount_verify(Mount *m) {
|
2013-09-26 20:14:24 +02:00
|
|
|
_cleanup_free_ char *e = NULL;
|
2015-12-09 16:02:10 +01:00
|
|
|
MountParameters *p;
|
2015-04-30 20:21:00 +02:00
|
|
|
int r;
|
2013-09-26 20:14:24 +02:00
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
assert(m);
|
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(m)->load_state != UNIT_LOADED)
|
2010-04-16 23:24:39 +02:00
|
|
|
return 0;
|
|
|
|
|
2017-07-31 12:32:09 +02:00
|
|
|
if (!m->from_fragment && !m->from_proc_self_mountinfo && !UNIT(m)->perpetual)
|
2010-05-21 03:32:21 +02:00
|
|
|
return -ENOENT;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(m->where, ".mount", &e);
|
|
|
|
if (r < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
return log_unit_error_errno(UNIT(m), r, "Failed to generate unit name from mount path: %m");
|
2010-04-16 23:24:39 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_has_name(UNIT(m), e)) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(m), "Where= setting doesn't match unit name. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-04-16 23:24:39 +02:00
|
|
|
}
|
|
|
|
|
2011-04-05 23:39:21 +02:00
|
|
|
if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(m), "Cannot create mount unit for API file system %s. Refusing.", m->where);
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2011-04-05 23:39:21 +02:00
|
|
|
}
|
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
p = get_mount_parameters_fragment(m);
|
|
|
|
if (p && !p->what) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(m), "What= setting is missing. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-05-14 02:29:45 +02:00
|
|
|
}
|
|
|
|
|
2012-07-19 23:47:10 +02:00
|
|
|
if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_error(UNIT(m), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2010-06-19 16:57:54 +02:00
|
|
|
}
|
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
static int mount_add_extras(Mount *m) {
|
|
|
|
Unit *u = UNIT(m);
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
assert(m);
|
|
|
|
|
|
|
|
if (u->fragment_path)
|
2012-06-29 01:47:24 +02:00
|
|
|
m->from_fragment = true;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
if (!m->where) {
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_to_path(u->id, &m->where);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-06-29 01:47:24 +02:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2018-05-31 16:39:31 +02:00
|
|
|
path_simplify(m->where, false);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (!u->description) {
|
2012-06-29 01:47:24 +02:00
|
|
|
r = unit_set_description(u, m->where);
|
|
|
|
if (r < 0)
|
2010-08-25 20:37:04 +02:00
|
|
|
return r;
|
2012-06-29 01:47:24 +02:00
|
|
|
}
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = mount_add_device_dependencies(m);
|
2012-06-29 01:47:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = mount_add_mount_dependencies(m);
|
2012-06-29 01:47:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = mount_add_quota_dependencies(m);
|
2012-06-29 01:47:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2014-03-19 20:40:05 +01:00
|
|
|
r = unit_patch_contexts(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-07-10 02:41:06 +02:00
|
|
|
|
2014-03-19 20:40:05 +01:00
|
|
|
r = unit_add_exec_dependencies(u, &m->exec_context);
|
2013-06-17 21:33:26 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-08-28 17:36:39 +02:00
|
|
|
r = unit_set_default_slice(u);
|
2012-06-29 01:47:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
r = mount_add_default_dependencies(m);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-03-19 20:40:05 +01:00
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-10-25 00:04:55 +02:00
|
|
|
static int mount_load_root_mount(Unit *u) {
|
|
|
|
assert(u);
|
|
|
|
|
|
|
|
if (!unit_has_name(u, SPECIAL_ROOT_MOUNT))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
u->perpetual = true;
|
|
|
|
u->default_dependencies = false;
|
|
|
|
|
|
|
|
/* The stdio/kmsg bridge socket is on /, in order to avoid a dep loop, don't use kmsg logging for -.mount */
|
|
|
|
MOUNT(u)->exec_context.std_output = EXEC_OUTPUT_NULL;
|
|
|
|
MOUNT(u)->exec_context.std_input = EXEC_INPUT_NULL;
|
|
|
|
|
|
|
|
if (!u->description)
|
|
|
|
u->description = strdup("Root Mount");
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
static int mount_load(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(u->load_state == UNIT_STUB);
|
|
|
|
|
2016-10-25 00:04:55 +02:00
|
|
|
r = mount_load_root_mount(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo || u->perpetual)
|
2012-06-29 01:50:31 +02:00
|
|
|
r = unit_load_fragment_and_dropin_optional(u);
|
|
|
|
else
|
|
|
|
r = unit_load_fragment_and_dropin(u);
|
2012-06-29 01:47:24 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-04-20 00:45:22 +02:00
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
/* This is a new unit? Then let's add in some extras */
|
|
|
|
if (u->load_state == UNIT_LOADED) {
|
|
|
|
r = mount_add_extras(m);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
return mount_verify(m);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void mount_set_state(Mount *m, MountState state) {
|
|
|
|
MountState old_state;
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
old_state = m->state;
|
|
|
|
m->state = state;
|
|
|
|
|
2017-09-25 19:25:50 +02:00
|
|
|
if (!MOUNT_STATE_WITH_PROCESS(state)) {
|
2013-11-19 21:12:59 +01:00
|
|
|
m->timer_event_source = sd_event_source_unref(m->timer_event_source);
|
2010-04-21 03:27:44 +02:00
|
|
|
mount_unwatch_control_pid(m);
|
2010-04-10 17:53:17 +02:00
|
|
|
m->control_command = NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (state != old_state)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(UNIT(m), "Changed %s -> %s", mount_state_to_string(old_state), mount_state_to_string(state));
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2018-06-01 19:06:19 +02:00
|
|
|
unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state],
|
|
|
|
m->reload_result == MOUNT_SUCCESS ? 0 : UNIT_NOTIFY_RELOAD_FAILURE);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2015-04-24 15:27:19 +02:00
|
|
|
static int mount_coldplug(Unit *u) {
|
2010-04-10 17:53:17 +02:00
|
|
|
Mount *m = MOUNT(u);
|
2010-04-21 03:27:44 +02:00
|
|
|
MountState new_state = MOUNT_DEAD;
|
|
|
|
int r;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(m->state == MOUNT_DEAD);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
if (m->deserialized_state != m->state)
|
|
|
|
new_state = m->deserialized_state;
|
|
|
|
else if (m->from_proc_self_mountinfo)
|
|
|
|
new_state = MOUNT_MOUNTED;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
if (new_state == m->state)
|
|
|
|
return 0;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2015-10-27 17:59:45 +01:00
|
|
|
if (m->control_pid > 0 &&
|
|
|
|
pid_is_unwaited(m->control_pid) &&
|
2017-09-25 19:25:50 +02:00
|
|
|
MOUNT_STATE_WITH_PROCESS(new_state)) {
|
2013-11-25 15:26:30 +01:00
|
|
|
|
|
|
|
r = unit_watch_pid(UNIT(m), m->control_pid);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = mount_arm_timer(m, usec_add(u->state_change_timestamp.monotonic, m->timeout_usec));
|
2013-11-25 15:26:30 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
if (!IN_SET(new_state, MOUNT_DEAD, MOUNT_FAILED)) {
|
2016-07-14 12:37:28 +02:00
|
|
|
(void) unit_setup_dynamic_creds(u);
|
2018-02-06 08:00:34 +01:00
|
|
|
(void) unit_setup_exec_runtime(u);
|
|
|
|
}
|
2016-07-14 12:37:28 +02:00
|
|
|
|
2013-11-25 15:26:30 +01:00
|
|
|
mount_set_state(m, new_state);
|
2010-04-10 17:53:17 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mount_dump(Unit *u, FILE *f, const char *prefix) {
|
2018-02-09 08:36:37 +01:00
|
|
|
char buf[FORMAT_TIMESPAN_MAX];
|
2010-04-10 17:53:17 +02:00
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
MountParameters *p;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(f);
|
|
|
|
|
2011-03-30 01:53:34 +02:00
|
|
|
p = get_mount_parameters(m);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"%sMount State: %s\n"
|
2012-02-03 03:27:25 +01:00
|
|
|
"%sResult: %s\n"
|
2010-04-10 17:53:17 +02:00
|
|
|
"%sWhere: %s\n"
|
|
|
|
"%sWhat: %s\n"
|
|
|
|
"%sFile System Type: %s\n"
|
|
|
|
"%sOptions: %s\n"
|
|
|
|
"%sFrom /proc/self/mountinfo: %s\n"
|
|
|
|
"%sFrom fragment: %s\n"
|
2016-11-29 22:50:21 +01:00
|
|
|
"%sExtrinsic: %s\n"
|
2016-08-26 17:57:22 +02:00
|
|
|
"%sDirectoryMode: %04o\n"
|
2016-08-27 16:42:05 +02:00
|
|
|
"%sSloppyOptions: %s\n"
|
2016-08-27 16:27:49 +02:00
|
|
|
"%sLazyUnmount: %s\n"
|
2018-01-30 09:09:59 +01:00
|
|
|
"%sForceUnmount: %s\n"
|
|
|
|
"%sTimoutSec: %s\n",
|
2010-04-21 03:27:44 +02:00
|
|
|
prefix, mount_state_to_string(m->state),
|
2012-02-03 03:27:25 +01:00
|
|
|
prefix, mount_result_to_string(m->result),
|
2010-04-10 17:53:17 +02:00
|
|
|
prefix, m->where,
|
2013-07-04 11:01:47 +02:00
|
|
|
prefix, p ? strna(p->what) : "n/a",
|
|
|
|
prefix, p ? strna(p->fstype) : "n/a",
|
|
|
|
prefix, p ? strna(p->options) : "n/a",
|
2010-04-10 17:53:17 +02:00
|
|
|
prefix, yes_no(m->from_proc_self_mountinfo),
|
|
|
|
prefix, yes_no(m->from_fragment),
|
2016-11-29 22:50:21 +01:00
|
|
|
prefix, yes_no(mount_is_extrinsic(m)),
|
2016-08-26 17:57:22 +02:00
|
|
|
prefix, m->directory_mode,
|
2016-08-27 16:42:05 +02:00
|
|
|
prefix, yes_no(m->sloppy_options),
|
2016-08-27 16:27:49 +02:00
|
|
|
prefix, yes_no(m->lazy_unmount),
|
2018-01-30 09:09:59 +01:00
|
|
|
prefix, yes_no(m->force_unmount),
|
|
|
|
prefix, format_timespan(buf, sizeof(buf), m->timeout_usec, USEC_PER_SEC));
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
if (m->control_pid > 0)
|
|
|
|
fprintf(f,
|
2013-12-30 23:22:26 +01:00
|
|
|
"%sControl PID: "PID_FMT"\n",
|
|
|
|
prefix, m->control_pid);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
exec_context_dump(&m->exec_context, f, prefix);
|
2012-07-19 23:47:10 +02:00
|
|
|
kill_context_dump(&m->kill_context, f, prefix);
|
2017-09-05 19:20:29 +02:00
|
|
|
cgroup_context_dump(&m->cgroup_context, f, prefix);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
|
2017-11-17 16:43:08 +01:00
|
|
|
|
2018-11-08 06:08:10 +01:00
|
|
|
_cleanup_(exec_params_clear) ExecParameters exec_params = {
|
2018-07-17 11:47:14 +02:00
|
|
|
.flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
|
|
|
|
.stdin_fd = -1,
|
|
|
|
.stdout_fd = -1,
|
|
|
|
.stderr_fd = -1,
|
|
|
|
.exec_fd = -1,
|
2014-08-23 15:28:37 +02:00
|
|
|
};
|
2017-11-17 16:43:08 +01:00
|
|
|
pid_t pid;
|
|
|
|
int r;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(c);
|
|
|
|
assert(_pid);
|
|
|
|
|
2017-11-17 16:43:08 +01:00
|
|
|
r = unit_prepare_exec(UNIT(m));
|
2016-07-14 12:37:28 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2018-10-31 15:49:19 +01:00
|
|
|
r = unit_set_exec_params(UNIT(m), &exec_params);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-08-23 15:28:37 +02:00
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
r = exec_spawn(UNIT(m),
|
|
|
|
c,
|
2013-06-27 04:14:27 +02:00
|
|
|
&m->exec_context,
|
2014-08-23 15:28:37 +02:00
|
|
|
&exec_params,
|
2013-11-27 20:23:18 +01:00
|
|
|
m->exec_runtime,
|
2016-07-14 12:37:28 +02:00
|
|
|
&m->dynamic_creds,
|
2013-06-27 04:14:27 +02:00
|
|
|
&pid);
|
|
|
|
if (r < 0)
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2013-06-27 04:14:27 +02:00
|
|
|
r = unit_watch_pid(UNIT(m), pid);
|
|
|
|
if (r < 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
/* FIXME: we need to do something here */
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
*_pid = pid;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static void mount_enter_dead(Mount *m, MountResult f) {
|
2010-04-10 17:53:17 +02:00
|
|
|
assert(m);
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (m->result == MOUNT_SUCCESS)
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = f;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2018-11-16 10:09:45 +01:00
|
|
|
unit_log_result(UNIT(m), m->result == MOUNT_SUCCESS, mount_result_to_string(m->result));
|
2016-07-14 12:37:28 +02:00
|
|
|
mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
|
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
m->exec_runtime = exec_runtime_unref(m->exec_runtime, true);
|
2013-11-27 20:23:18 +01:00
|
|
|
|
core: add {State,Cache,Log,Configuration}Directory= (#6384)
This introduces {State,Cache,Log,Configuration}Directory= those are
similar to RuntimeDirectory=. They create the directories under
/var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode
specified in {State,Cache,Log,Configuration}DirectoryMode=.
This also fixes #6391.
2017-07-18 14:34:52 +02:00
|
|
|
exec_context_destroy_runtime_directory(&m->exec_context, UNIT(m)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
|
2014-03-03 17:14:07 +01:00
|
|
|
|
2016-08-01 19:24:40 +02:00
|
|
|
unit_unref_uid_gid(UNIT(m), true);
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_destroy(&m->dynamic_creds);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static void mount_enter_mounted(Mount *m, MountResult f) {
|
2010-04-13 02:06:27 +02:00
|
|
|
assert(m);
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (m->result == MOUNT_SUCCESS)
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = f;
|
2010-04-13 02:06:27 +02:00
|
|
|
|
|
|
|
mount_set_state(m, MOUNT_MOUNTED);
|
|
|
|
}
|
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
static void mount_enter_dead_or_mounted(Mount *m, MountResult f) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* Enter DEAD or MOUNTED state, depending on what the kernel currently says about the mount point. We use this
|
|
|
|
* whenever we executed an operation, so that our internal state reflects what the kernel says again, after all
|
|
|
|
* ultimately we just mirror the kernel's internal state on this. */
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
|
|
|
mount_enter_mounted(m, f);
|
|
|
|
else
|
|
|
|
mount_enter_dead(m, f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int state_to_kill_operation(MountState state) {
|
|
|
|
switch (state) {
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
|
|
|
case MOUNT_UNMOUNTING_SIGTERM:
|
|
|
|
return KILL_TERMINATE;
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING_SIGKILL:
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
|
|
|
return KILL_KILL;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return _KILL_OPERATION_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
core: remember first unit failure, not last unit failure
Previously, the result value of a unit was overriden with each failure that
took place, so that the result always reported the last failure that took
place.
With this commit this is changed, so that the first failure taking place is
stored instead. This should normally not matter much as multiple failures are
sufficiently uncommon. However, it improves one behaviour: if we send SIGABRT
to a service due to a watchdog timeout, then this currently would be reported
as "coredump" failure, rather than the "watchodg" failure it really is. Hence,
in order to report information about the type of the failure, and not about
the effect of it, let's change this from all unit type to store the first, not
the last failure.
This addresses the issue pointed out here:
https://github.com/systemd/systemd/pull/3818#discussion_r73433520
2016-08-04 21:14:27 +02:00
|
|
|
if (m->result == MOUNT_SUCCESS)
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = f;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2013-01-26 05:53:30 +01:00
|
|
|
r = unit_kill_context(
|
|
|
|
UNIT(m),
|
|
|
|
&m->kill_context,
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
state_to_kill_operation(state),
|
2013-01-26 05:53:30 +01:00
|
|
|
-1,
|
|
|
|
m->control_pid,
|
|
|
|
false);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2013-01-26 05:53:30 +01:00
|
|
|
if (r > 0) {
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = mount_arm_timer(m, usec_add(now(CLOCK_MONOTONIC), m->timeout_usec));
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
2010-04-13 02:06:27 +02:00
|
|
|
goto fail;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
mount_set_state(m, state);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
} else if (state == MOUNT_REMOUNTING_SIGTERM && m->kill_context.send_sigkill)
|
2014-01-29 14:58:04 +01:00
|
|
|
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
else if (IN_SET(state, MOUNT_REMOUNTING_SIGTERM, MOUNT_REMOUNTING_SIGKILL))
|
2012-02-03 03:10:56 +01:00
|
|
|
mount_enter_mounted(m, MOUNT_SUCCESS);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
else if (state == MOUNT_UNMOUNTING_SIGTERM && m->kill_context.send_sigkill)
|
2014-01-29 14:58:04 +01:00
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
|
2010-04-13 02:06:27 +02:00
|
|
|
else
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(m), r, "Failed to kill processes: %m");
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
|
2014-08-15 01:05:47 +02:00
|
|
|
}
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static void mount_enter_unmounting(Mount *m) {
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2014-12-12 20:12:35 +01:00
|
|
|
/* Start counting our attempts */
|
|
|
|
if (!IN_SET(m->state,
|
|
|
|
MOUNT_UNMOUNTING,
|
|
|
|
MOUNT_UNMOUNTING_SIGTERM,
|
|
|
|
MOUNT_UNMOUNTING_SIGKILL))
|
|
|
|
m->n_retry_umount = 0;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
m->control_command_id = MOUNT_EXEC_UNMOUNT;
|
|
|
|
m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2017-06-07 14:28:23 +02:00
|
|
|
r = exec_command_set(m->control_command, UMOUNT_PATH, m->where, "-c", NULL);
|
2016-08-26 17:57:22 +02:00
|
|
|
if (r >= 0 && m->lazy_unmount)
|
|
|
|
r = exec_command_append(m->control_command, "-l", NULL);
|
2016-08-27 16:27:49 +02:00
|
|
|
if (r >= 0 && m->force_unmount)
|
|
|
|
r = exec_command_append(m->control_command, "-f", NULL);
|
2014-12-12 20:12:35 +01:00
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
mount_unwatch_control_pid(m);
|
2010-04-11 00:22:36 +02:00
|
|
|
|
2014-12-12 20:12:35 +01:00
|
|
|
r = mount_spawn(m, m->control_command, &m->control_pid);
|
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
mount_set_state(m, MOUNT_UNMOUNTING);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(m), r, "Failed to run 'umount' task: %m");
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
static void mount_enter_mounting(Mount *m) {
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
2011-03-30 01:53:34 +02:00
|
|
|
MountParameters *p;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2018-01-19 18:28:38 +01:00
|
|
|
r = unit_fail_if_noncanonical(UNIT(m), m->where);
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
(void) mkdir_p_label(m->where, m->directory_mode);
|
2010-07-02 00:28:44 +02:00
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
unit_warn_if_dir_nonempty(UNIT(m), m->where);
|
2012-09-18 18:40:31 +02:00
|
|
|
|
2017-11-24 22:02:22 +01:00
|
|
|
unit_warn_leftover_processes(UNIT(m));
|
|
|
|
|
|
|
|
m->control_command_id = MOUNT_EXEC_MOUNT;
|
|
|
|
m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
|
|
|
|
|
2011-03-30 01:53:34 +02:00
|
|
|
/* Create the source directory for bind-mounts if needed */
|
2012-05-22 19:23:33 +02:00
|
|
|
p = get_mount_parameters_fragment(m);
|
2011-03-30 01:53:34 +02:00
|
|
|
if (p && mount_is_bind(p))
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
(void) mkdir_p_label(p->what, m->directory_mode);
|
2014-08-15 01:05:47 +02:00
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
if (p) {
|
core/mount: filter out noauto,auto,nofail,fail options
We passed the full option string from fstab to /bin/mount. It would in
turn pass the full option string to its helper, if it needed to invoke
one. Some helpers would ignore things like "nofail", but others would
be confused. We could try to get all helpers to ignore those
"meta-options", but it seems better to simply filter them out.
In our model, /bin/mount simply has no business in knowing whether the
mount was configured as fail or nofail, auto or noauto, in the
fstab. If systemd tells invokes a command to mount something, and it
fails, it should always return an error. It seems cleaner to filter
out the option, since then there's no doubt how the command should
behave.
https://bugzilla.redhat.com/show_bug.cgi?id=1177823
2015-01-11 06:27:37 +01:00
|
|
|
_cleanup_free_ char *opts = NULL;
|
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
r = fstab_filter_options(p->options, "nofail\0" "noauto\0" "auto\0", NULL, NULL, &opts);
|
core/mount: filter out noauto,auto,nofail,fail options
We passed the full option string from fstab to /bin/mount. It would in
turn pass the full option string to its helper, if it needed to invoke
one. Some helpers would ignore things like "nofail", but others would
be confused. We could try to get all helpers to ignore those
"meta-options", but it seems better to simply filter them out.
In our model, /bin/mount simply has no business in knowing whether the
mount was configured as fail or nofail, auto or noauto, in the
fstab. If systemd tells invokes a command to mount something, and it
fails, it should always return an error. It seems cleaner to filter
out the option, since then there's no doubt how the command should
behave.
https://bugzilla.redhat.com/show_bug.cgi?id=1177823
2015-01-11 06:27:37 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
r = exec_command_set(m->control_command, MOUNT_PATH, p->what, m->where, NULL);
|
2015-01-01 20:25:18 +01:00
|
|
|
if (r >= 0 && m->sloppy_options)
|
|
|
|
r = exec_command_append(m->control_command, "-s", NULL);
|
2015-12-09 16:02:10 +01:00
|
|
|
if (r >= 0 && p->fstype)
|
|
|
|
r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
|
2015-01-12 13:46:39 +01:00
|
|
|
if (r >= 0 && !isempty(opts))
|
core/mount: filter out noauto,auto,nofail,fail options
We passed the full option string from fstab to /bin/mount. It would in
turn pass the full option string to its helper, if it needed to invoke
one. Some helpers would ignore things like "nofail", but others would
be confused. We could try to get all helpers to ignore those
"meta-options", but it seems better to simply filter them out.
In our model, /bin/mount simply has no business in knowing whether the
mount was configured as fail or nofail, auto or noauto, in the
fstab. If systemd tells invokes a command to mount something, and it
fails, it should always return an error. It seems cleaner to filter
out the option, since then there's no doubt how the command should
behave.
https://bugzilla.redhat.com/show_bug.cgi?id=1177823
2015-01-11 06:27:37 +01:00
|
|
|
r = exec_command_append(m->control_command, "-o", opts, NULL);
|
2015-01-01 20:25:18 +01:00
|
|
|
} else
|
2010-04-10 17:53:17 +02:00
|
|
|
r = -ENOENT;
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
mount_unwatch_control_pid(m);
|
2010-04-11 00:22:36 +02:00
|
|
|
|
2012-09-18 18:40:31 +02:00
|
|
|
r = mount_spawn(m, m->control_command, &m->control_pid);
|
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
mount_set_state(m, MOUNT_MOUNTING);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(m), r, "Failed to run 'mount' task: %m");
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2017-09-25 18:56:19 +02:00
|
|
|
static void mount_set_reload_result(Mount *m, MountResult result) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* Only store the first error we encounter */
|
|
|
|
if (m->reload_result != MOUNT_SUCCESS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
m->reload_result = result;
|
|
|
|
}
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static void mount_enter_remounting(Mount *m) {
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
2015-12-09 16:02:10 +01:00
|
|
|
MountParameters *p;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2017-09-25 18:56:19 +02:00
|
|
|
/* Reset reload result when we are about to start a new remount operation */
|
|
|
|
m->reload_result = MOUNT_SUCCESS;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
m->control_command_id = MOUNT_EXEC_REMOUNT;
|
|
|
|
m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
p = get_mount_parameters_fragment(m);
|
|
|
|
if (p) {
|
2010-04-10 17:53:17 +02:00
|
|
|
const char *o;
|
|
|
|
|
2015-12-09 16:02:10 +01:00
|
|
|
if (p->options)
|
|
|
|
o = strjoina("remount,", p->options);
|
2013-11-19 21:12:59 +01:00
|
|
|
else
|
2010-04-10 17:53:17 +02:00
|
|
|
o = "remount";
|
|
|
|
|
2015-05-13 15:43:04 +02:00
|
|
|
r = exec_command_set(m->control_command, MOUNT_PATH,
|
2015-12-09 16:02:10 +01:00
|
|
|
p->what, m->where,
|
2015-01-01 20:25:18 +01:00
|
|
|
"-o", o, NULL);
|
|
|
|
if (r >= 0 && m->sloppy_options)
|
|
|
|
r = exec_command_append(m->control_command, "-s", NULL);
|
2015-12-09 16:02:10 +01:00
|
|
|
if (r >= 0 && p->fstype)
|
|
|
|
r = exec_command_append(m->control_command, "-t", p->fstype, NULL);
|
2012-05-22 19:23:33 +02:00
|
|
|
} else
|
2010-04-10 17:53:17 +02:00
|
|
|
r = -ENOENT;
|
2010-10-12 04:06:21 +02:00
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
mount_unwatch_control_pid(m);
|
2010-04-11 00:22:36 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = mount_spawn(m, m->control_command, &m->control_pid);
|
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
mount_set_state(m, MOUNT_REMOUNTING);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_warning_errno(UNIT(m), r, "Failed to run 'remount' task: %m");
|
2017-09-25 18:56:19 +02:00
|
|
|
mount_set_reload_result(m, MOUNT_FAILURE_RESOURCES);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mount_start(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
int r;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* We cannot fulfill this request right now, try again later
|
|
|
|
* please! */
|
2016-10-10 22:28:38 +02:00
|
|
|
if (IN_SET(m->state,
|
|
|
|
MOUNT_UNMOUNTING,
|
|
|
|
MOUNT_UNMOUNTING_SIGTERM,
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
MOUNT_UNMOUNTING_SIGKILL))
|
2010-04-10 17:53:17 +02:00
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
/* Already on it! */
|
2010-10-12 04:06:21 +02:00
|
|
|
if (m->state == MOUNT_MOUNTING)
|
2010-04-10 17:53:17 +02:00
|
|
|
return 0;
|
|
|
|
|
2016-10-10 22:28:38 +02:00
|
|
|
assert(IN_SET(m->state, MOUNT_DEAD, MOUNT_FAILED));
|
2010-04-10 17:53:17 +02:00
|
|
|
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
r = unit_start_limit_test(u);
|
|
|
|
if (r < 0) {
|
|
|
|
mount_enter_dead(m, MOUNT_FAILURE_START_LIMIT_HIT);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2016-08-30 23:18:46 +02:00
|
|
|
r = unit_acquire_invocation_id(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = MOUNT_SUCCESS;
|
|
|
|
m->reload_result = MOUNT_SUCCESS;
|
2018-07-17 19:36:46 +02:00
|
|
|
exec_command_reset_status_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
|
2017-11-17 16:43:08 +01:00
|
|
|
|
|
|
|
u->reset_accounting = true;
|
2012-02-03 03:10:56 +01:00
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
mount_enter_mounting(m);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mount_stop(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
switch (m->state) {
|
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING:
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
|
|
|
case MOUNT_UNMOUNTING_SIGTERM:
|
|
|
|
/* Already on it */
|
2010-04-10 17:53:17 +02:00
|
|
|
return 0;
|
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
case MOUNT_MOUNTING:
|
|
|
|
case MOUNT_MOUNTING_DONE:
|
|
|
|
case MOUNT_REMOUNTING:
|
|
|
|
/* If we are still waiting for /bin/mount, we go directly into kill mode. */
|
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_SUCCESS);
|
|
|
|
return 0;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
|
|
|
/* If we are already waiting for a hung remount, convert this to the matching unmounting state */
|
|
|
|
mount_set_state(m, MOUNT_UNMOUNTING_SIGTERM);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING_SIGKILL:
|
|
|
|
/* as above */
|
|
|
|
mount_set_state(m, MOUNT_UNMOUNTING_SIGKILL);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case MOUNT_MOUNTED:
|
|
|
|
mount_enter_unmounting(m);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Unexpected state.");
|
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mount_reload(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(m->state == MOUNT_MOUNTED);
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
mount_enter_remounting(m);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
|
2015-07-16 21:39:56 +02:00
|
|
|
return 1;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_item(f, "state", mount_state_to_string(m->state));
|
|
|
|
(void) serialize_item(f, "result", mount_result_to_string(m->result));
|
|
|
|
(void) serialize_item(f, "reload-result", mount_result_to_string(m->reload_result));
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
if (m->control_pid > 0)
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_item_format(f, "control-pid", PID_FMT, m->control_pid);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
if (m->control_command_id >= 0)
|
2018-10-17 20:40:09 +02:00
|
|
|
(void) serialize_item(f, "control-command", mount_exec_command_to_string(m->control_command_id));
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(key);
|
|
|
|
assert(value);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
if (streq(key, "state")) {
|
|
|
|
MountState state;
|
|
|
|
|
|
|
|
if ((state = mount_state_from_string(value)) < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse state value: %s", value);
|
2010-04-21 03:27:44 +02:00
|
|
|
else
|
|
|
|
m->deserialized_state = state;
|
2012-02-03 03:10:56 +01:00
|
|
|
} else if (streq(key, "result")) {
|
|
|
|
MountResult f;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
f = mount_result_from_string(value);
|
|
|
|
if (f < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse result value: %s", value);
|
2012-02-03 03:10:56 +01:00
|
|
|
else if (f != MOUNT_SUCCESS)
|
|
|
|
m->result = f;
|
|
|
|
|
|
|
|
} else if (streq(key, "reload-result")) {
|
|
|
|
MountResult f;
|
|
|
|
|
|
|
|
f = mount_result_from_string(value);
|
|
|
|
if (f < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse reload result value: %s", value);
|
2012-02-03 03:10:56 +01:00
|
|
|
else if (f != MOUNT_SUCCESS)
|
|
|
|
m->reload_result = f;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
} else if (streq(key, "control-pid")) {
|
2010-06-17 22:55:53 +02:00
|
|
|
pid_t pid;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2010-08-11 22:04:22 +02:00
|
|
|
if (parse_pid(value, &pid) < 0)
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Failed to parse control-pid value: %s", value);
|
2010-04-21 03:27:44 +02:00
|
|
|
else
|
2010-06-17 22:55:53 +02:00
|
|
|
m->control_pid = pid;
|
2010-04-21 03:27:44 +02:00
|
|
|
} else if (streq(key, "control-command")) {
|
|
|
|
MountExecCommand id;
|
|
|
|
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
id = mount_exec_command_from_string(value);
|
|
|
|
if (id < 0)
|
|
|
|
log_unit_debug(u, "Failed to parse exec-command value: %s", value);
|
2010-04-21 03:27:44 +02:00
|
|
|
else {
|
|
|
|
m->control_command_id = id;
|
|
|
|
m->control_command = m->exec_command + id;
|
|
|
|
}
|
|
|
|
} else
|
core,network: major per-object logging rework
This changes log_unit_info() (and friends) to take a real Unit* object
insted of just a unit name as parameter. The call will now prefix all
logged messages with the unit name, thus allowing the unit name to be
dropped from the various passed romat strings, simplifying invocations
drastically, and unifying log output across messages. Also, UNIT= vs.
USER_UNIT= is now derived from the Manager object attached to the Unit
object, instead of getpid(). This has the benefit of correcting the
field for --test runs.
Also contains a couple of other logging improvements:
- Drops a couple of strerror() invocations in favour of using %m.
- Not only .mount units now warn if a symlinks exist for the mount
point already, .automount units do that too, now.
- A few invocations of log_struct() that didn't actually pass any
additional structured data have been replaced by simpler invocations
of log_unit_info() and friends.
- For structured data a new LOG_UNIT_MESSAGE() macro has been added,
that works like LOG_MESSAGE() but prefixes the message with the unit
name. Similar, there's now LOG_LINK_MESSAGE() and
LOG_NETDEV_MESSAGE().
- For structured data new LOG_UNIT_ID(), LOG_LINK_INTERFACE(),
LOG_NETDEV_INTERFACE() macros have been added that generate the
necessary per object fields. The old log_unit_struct() call has been
removed in favour of these new macros used in raw log_struct()
invocations. In addition to removing one more function call this
allows generated structured log messages that contain two object
fields, as necessary for example for network interfaces that are
joined into another network interface, and whose messages shall be
indexed by both.
- The LOG_ERRNO() macro has been removed, in favour of
log_struct_errno(). The latter has the benefit of ensuring that %m in
format strings is properly resolved to the specified error number.
- A number of logging messages have been converted to use
log_unit_info() instead of log_info()
- The client code in sysv-generator no longer #includes core code from
src/core/.
- log_unit_full_errno() has been removed, log_unit_full() instead takes
an errno now, too.
- log_unit_info(), log_link_info(), log_netdev_info() and friends, now
avoid double evaluation of their parameters
2015-05-11 20:38:21 +02:00
|
|
|
log_unit_debug(u, "Unknown serialization key: %s", key);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static UnitActiveState mount_active_state(Unit *u) {
|
2010-04-10 17:53:17 +02:00
|
|
|
assert(u);
|
|
|
|
|
|
|
|
return state_translation_table[MOUNT(u)->state];
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static const char *mount_sub_state_to_string(Unit *u) {
|
2010-04-13 20:59:01 +02:00
|
|
|
assert(u);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
return mount_state_to_string(MOUNT(u)->state);
|
2010-04-13 20:59:01 +02:00
|
|
|
}
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
_pure_ static bool mount_may_gc(Unit *u) {
|
2010-04-21 06:01:13 +02:00
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
if (m->from_proc_self_mountinfo)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
2010-04-21 06:01:13 +02:00
|
|
|
}
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
|
|
|
|
Mount *m = MOUNT(u);
|
2012-02-03 03:10:56 +01:00
|
|
|
MountResult f;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
assert(pid >= 0);
|
|
|
|
|
2010-06-16 05:10:31 +02:00
|
|
|
if (pid != m->control_pid)
|
|
|
|
return;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
m->control_pid = 0;
|
|
|
|
|
2016-10-10 22:07:30 +02:00
|
|
|
if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
|
2012-02-03 03:10:56 +01:00
|
|
|
f = MOUNT_SUCCESS;
|
|
|
|
else if (code == CLD_EXITED)
|
|
|
|
f = MOUNT_FAILURE_EXIT_CODE;
|
|
|
|
else if (code == CLD_KILLED)
|
|
|
|
f = MOUNT_FAILURE_SIGNAL;
|
|
|
|
else if (code == CLD_DUMPED)
|
|
|
|
f = MOUNT_FAILURE_CORE_DUMP;
|
|
|
|
else
|
|
|
|
assert_not_reached("Unknown code");
|
|
|
|
|
2017-09-25 18:56:19 +02:00
|
|
|
if (IN_SET(m->state, MOUNT_REMOUNTING, MOUNT_REMOUNTING_SIGKILL, MOUNT_REMOUNTING_SIGTERM))
|
|
|
|
mount_set_reload_result(m, f);
|
|
|
|
else if (m->result == MOUNT_SUCCESS)
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = f;
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
if (m->control_command) {
|
2011-05-18 01:07:31 +02:00
|
|
|
exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
|
2012-02-03 03:10:56 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
m->control_command = NULL;
|
|
|
|
m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
|
|
|
|
}
|
|
|
|
|
2018-11-13 22:10:38 +01:00
|
|
|
unit_log_process_exit(
|
|
|
|
u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
|
|
|
|
"Mount process",
|
|
|
|
mount_exec_command_to_string(m->control_command_id),
|
|
|
|
code, status);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2018-01-20 21:05:52 +01:00
|
|
|
/* Note that due to the io event priority logic, we can be sure the new mountinfo is loaded
|
|
|
|
* before we process the SIGCHLD for the mount command. */
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
switch (m->state) {
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING:
|
2018-01-20 21:05:52 +01:00
|
|
|
/* Our mount point has not appeared in mountinfo. Something went wrong. */
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2018-01-20 21:05:52 +01:00
|
|
|
if (f == MOUNT_SUCCESS) {
|
|
|
|
/* Either /bin/mount has an unexpected definition of success,
|
|
|
|
* or someone raced us and we lost. */
|
|
|
|
log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
|
|
|
|
f = MOUNT_FAILURE_PROTOCOL;
|
|
|
|
}
|
|
|
|
mount_enter_dead(m, f);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING_DONE:
|
|
|
|
mount_enter_mounted(m, f);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
2011-01-20 13:17:22 +01:00
|
|
|
case MOUNT_REMOUNTING:
|
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
case MOUNT_REMOUNTING_SIGKILL:
|
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
|
2011-01-20 13:17:22 +01:00
|
|
|
break;
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
case MOUNT_UNMOUNTING:
|
|
|
|
|
2018-01-13 18:22:46 +01:00
|
|
|
if (f == MOUNT_SUCCESS && m->from_proc_self_mountinfo) {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
|
|
|
|
/* Still a mount point? If so, let's try again. Most likely there were multiple mount points
|
2018-01-22 18:42:25 +01:00
|
|
|
* stacked on top of each other. We might exceed the timeout specified by the user overall,
|
|
|
|
* but we will stop as soon as any one umount times out. */
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
|
|
|
|
if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
|
|
|
|
log_unit_debug(u, "Mount still present, trying again.");
|
|
|
|
m->n_retry_umount++;
|
|
|
|
mount_enter_unmounting(m);
|
|
|
|
} else {
|
2018-01-20 21:05:52 +01:00
|
|
|
log_unit_warning(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_mounted(m, f);
|
|
|
|
}
|
|
|
|
} else
|
2018-01-13 18:22:46 +01:00
|
|
|
mount_enter_dead_or_mounted(m, f);
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
2018-01-22 18:42:25 +01:00
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
|
|
|
case MOUNT_UNMOUNTING_SIGTERM:
|
|
|
|
mount_enter_dead_or_mounted(m, f);
|
|
|
|
break;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Uh, control process died at wrong time.");
|
|
|
|
}
|
2010-08-20 02:26:05 +02:00
|
|
|
|
|
|
|
/* Notify clients about changed exit status */
|
|
|
|
unit_add_to_dbus_queue(u);
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
|
|
|
|
Mount *m = MOUNT(userdata);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
assert(m);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(m->timer_event_source == source);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
switch (m->state) {
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING:
|
|
|
|
case MOUNT_MOUNTING_DONE:
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
|
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING:
|
2017-10-02 15:40:15 +02:00
|
|
|
log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
|
|
|
|
mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
|
|
|
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2012-07-19 23:47:10 +02:00
|
|
|
if (m->kill_context.send_sigkill) {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
|
|
|
|
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
|
2011-01-18 22:55:54 +01:00
|
|
|
} else {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
|
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
|
2011-01-18 22:55:54 +01:00
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
case MOUNT_REMOUNTING_SIGKILL:
|
|
|
|
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
|
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING:
|
2017-10-02 15:40:15 +02:00
|
|
|
log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
if (m->kill_context.send_sigkill) {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
|
2012-02-03 03:10:56 +01:00
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
} else {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
|
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
|
|
|
|
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Timeout at wrong time.");
|
|
|
|
}
|
2013-11-19 21:12:59 +01:00
|
|
|
|
|
|
|
return 0;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2017-01-16 21:19:13 +01:00
|
|
|
typedef struct {
|
|
|
|
bool is_mounted;
|
|
|
|
bool just_mounted;
|
|
|
|
bool just_changed;
|
|
|
|
} MountSetupFlags;
|
|
|
|
|
|
|
|
static int mount_setup_new_unit(
|
|
|
|
Unit *u,
|
|
|
|
const char *what,
|
|
|
|
const char *where,
|
|
|
|
const char *options,
|
|
|
|
const char *fstype,
|
|
|
|
MountSetupFlags *flags) {
|
|
|
|
|
|
|
|
MountParameters *p;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(flags);
|
|
|
|
|
|
|
|
u->source_path = strdup("/proc/self/mountinfo");
|
|
|
|
MOUNT(u)->where = strdup(where);
|
2017-01-20 01:45:58 +01:00
|
|
|
if (!u->source_path || !MOUNT(u)->where)
|
2017-01-16 21:19:13 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Make sure to initialize those fields before mount_is_extrinsic(). */
|
|
|
|
MOUNT(u)->from_proc_self_mountinfo = true;
|
|
|
|
p = &MOUNT(u)->parameters_proc_self_mountinfo;
|
|
|
|
|
|
|
|
p->what = strdup(what);
|
|
|
|
p->options = strdup(options);
|
|
|
|
p->fstype = strdup(fstype);
|
|
|
|
if (!p->what || !p->options || !p->fstype)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!mount_is_extrinsic(MOUNT(u))) {
|
|
|
|
const char *target;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
target = mount_is_network(p) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
|
2017-01-16 21:19:13 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2018-09-15 19:57:52 +02:00
|
|
|
r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
|
2017-01-16 21:19:13 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2017-01-20 01:46:47 +01:00
|
|
|
unit_add_to_load_queue(u);
|
2017-01-16 21:19:13 +01:00
|
|
|
flags->is_mounted = true;
|
|
|
|
flags->just_mounted = true;
|
|
|
|
flags->just_changed = true;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mount_setup_existing_unit(
|
|
|
|
Unit *u,
|
|
|
|
const char *what,
|
|
|
|
const char *where,
|
|
|
|
const char *options,
|
|
|
|
const char *fstype,
|
|
|
|
MountSetupFlags *flags) {
|
|
|
|
|
|
|
|
MountParameters *p;
|
|
|
|
bool load_extras = false;
|
|
|
|
int r1, r2, r3;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(flags);
|
|
|
|
|
|
|
|
if (!MOUNT(u)->where) {
|
|
|
|
MOUNT(u)->where = strdup(where);
|
|
|
|
if (!MOUNT(u)->where)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure to initialize those fields before mount_is_extrinsic(). */
|
|
|
|
p = &MOUNT(u)->parameters_proc_self_mountinfo;
|
|
|
|
|
|
|
|
r1 = free_and_strdup(&p->what, what);
|
|
|
|
r2 = free_and_strdup(&p->options, options);
|
|
|
|
r3 = free_and_strdup(&p->fstype, fstype);
|
|
|
|
if (r1 < 0 || r2 < 0 || r3 < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
flags->just_changed = r1 > 0 || r2 > 0 || r3 > 0;
|
|
|
|
flags->is_mounted = true;
|
2018-01-05 19:28:23 +01:00
|
|
|
flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
|
2017-01-16 21:19:13 +01:00
|
|
|
|
|
|
|
MOUNT(u)->from_proc_self_mountinfo = true;
|
|
|
|
|
|
|
|
if (!mount_is_extrinsic(MOUNT(u)) && mount_is_network(p)) {
|
|
|
|
/* _netdev option may have shown up late, or on a
|
|
|
|
* remount. Add remote-fs dependencies, even though
|
|
|
|
* local-fs ones may already be there.
|
|
|
|
*
|
|
|
|
* Note: due to a current limitation (we don't track
|
|
|
|
* in the dependency "Set*" objects who created a
|
|
|
|
* dependency), we can only add deps, never lose them,
|
|
|
|
* until the next full daemon-reload. */
|
2018-09-15 19:57:52 +02:00
|
|
|
unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT);
|
2017-01-16 21:19:13 +01:00
|
|
|
load_extras = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (u->load_state == UNIT_NOT_FOUND) {
|
|
|
|
u->load_state = UNIT_LOADED;
|
|
|
|
u->load_error = 0;
|
|
|
|
|
|
|
|
/* Load in the extras later on, after we
|
|
|
|
* finished initialization of the unit */
|
|
|
|
|
|
|
|
/* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
|
|
|
|
load_extras = true;
|
|
|
|
flags->just_changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (load_extras)
|
|
|
|
return mount_add_extras(MOUNT(u));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
static int mount_setup_unit(
|
2010-04-10 17:53:17 +02:00
|
|
|
Manager *m,
|
|
|
|
const char *what,
|
|
|
|
const char *where,
|
|
|
|
const char *options,
|
|
|
|
const char *fstype,
|
|
|
|
bool set_flags) {
|
2014-01-07 00:25:05 +01:00
|
|
|
|
2017-01-16 21:19:13 +01:00
|
|
|
_cleanup_free_ char *e = NULL;
|
|
|
|
MountSetupFlags flags;
|
2014-01-07 00:25:05 +01:00
|
|
|
Unit *u;
|
|
|
|
int r;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
assert(m);
|
2010-01-29 02:07:41 +01:00
|
|
|
assert(what);
|
|
|
|
assert(where);
|
2010-04-10 17:53:17 +02:00
|
|
|
assert(options);
|
|
|
|
assert(fstype);
|
|
|
|
|
|
|
|
/* Ignore API mount points. They should never be referenced in
|
|
|
|
* dependencies ever. */
|
2011-04-05 23:39:21 +02:00
|
|
|
if (mount_point_is_api(where) || mount_point_ignore(where))
|
2010-11-11 11:15:16 +01:00
|
|
|
return 0;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2010-04-16 23:24:39 +02:00
|
|
|
if (streq(fstype, "autofs"))
|
|
|
|
return 0;
|
|
|
|
|
2010-05-14 02:29:45 +02:00
|
|
|
/* probably some kind of swap, ignore */
|
|
|
|
if (!is_path(where))
|
2010-01-29 02:07:41 +01:00
|
|
|
return 0;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(where, ".mount", &e);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2012-01-15 10:53:49 +01:00
|
|
|
u = manager_get_unit(m, e);
|
|
|
|
if (!u) {
|
2017-01-16 21:19:13 +01:00
|
|
|
/* First time we see this mount point meaning that it's
|
|
|
|
* not been initiated by a mount unit but rather by the
|
|
|
|
* sysadmin having called mount(8) directly. */
|
2016-10-25 00:29:05 +02:00
|
|
|
r = unit_new_for_name(m, sizeof(Mount), e, &u);
|
2010-01-29 02:07:41 +01:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2017-01-16 21:19:13 +01:00
|
|
|
r = mount_setup_new_unit(u, what, where, options, fstype, &flags);
|
|
|
|
if (r < 0)
|
|
|
|
unit_free(u);
|
|
|
|
} else
|
|
|
|
r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2017-01-16 21:19:13 +01:00
|
|
|
if (r < 0)
|
2010-04-10 17:53:17 +02:00
|
|
|
goto fail;
|
2014-02-26 04:27:50 +01:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
if (set_flags) {
|
2017-01-16 21:19:13 +01:00
|
|
|
MOUNT(u)->is_mounted = flags.is_mounted;
|
|
|
|
MOUNT(u)->just_mounted = flags.just_mounted;
|
|
|
|
MOUNT(u)->just_changed = flags.just_changed;
|
2012-10-16 19:50:26 +02:00
|
|
|
}
|
|
|
|
|
2017-01-16 21:19:13 +01:00
|
|
|
if (flags.just_changed)
|
2014-02-26 04:27:50 +01:00
|
|
|
unit_add_to_dbus_queue(u);
|
2010-02-05 00:38:41 +01:00
|
|
|
|
2010-01-29 02:07:41 +01:00
|
|
|
return 0;
|
|
|
|
fail:
|
2018-08-07 08:48:37 +02:00
|
|
|
return log_warning_errno(r, "Failed to set up mount unit: %m");
|
2010-01-29 02:07:41 +01:00
|
|
|
}
|
|
|
|
|
2010-01-29 06:04:08 +01:00
|
|
|
static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
|
2015-02-27 21:55:08 +01:00
|
|
|
_cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
|
|
|
|
_cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
|
2010-10-12 04:06:21 +02:00
|
|
|
int r = 0;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
t = mnt_new_table();
|
|
|
|
i = mnt_new_iter(MNT_ITER_FORWARD);
|
2018-03-14 11:32:30 +01:00
|
|
|
if (!t || !i)
|
2015-02-27 21:55:08 +01:00
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
r = mnt_table_parse_mtab(t, NULL);
|
2014-11-28 19:02:15 +01:00
|
|
|
if (r < 0)
|
2015-02-27 21:55:08 +01:00
|
|
|
return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2014-11-28 19:02:15 +01:00
|
|
|
r = 0;
|
|
|
|
for (;;) {
|
2018-03-14 11:32:30 +01:00
|
|
|
struct libmnt_fs *fs;
|
2014-11-24 05:33:37 +01:00
|
|
|
const char *device, *path, *options, *fstype;
|
2015-04-06 20:11:41 +02:00
|
|
|
_cleanup_free_ char *d = NULL, *p = NULL;
|
2014-11-24 05:33:37 +01:00
|
|
|
int k;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
k = mnt_table_next_fs(t, i, &fs);
|
2014-11-28 19:02:15 +01:00
|
|
|
if (k == 1)
|
|
|
|
break;
|
2015-02-27 21:55:08 +01:00
|
|
|
if (k < 0)
|
|
|
|
return log_error_errno(k, "Failed to get next entry from /proc/self/mountinfo: %m");
|
2014-11-28 19:02:15 +01:00
|
|
|
|
2014-11-24 05:33:37 +01:00
|
|
|
device = mnt_fs_get_source(fs);
|
|
|
|
path = mnt_fs_get_target(fs);
|
|
|
|
options = mnt_fs_get_options(fs);
|
|
|
|
fstype = mnt_fs_get_fstype(fs);
|
2010-06-02 23:03:39 +02:00
|
|
|
|
2015-06-04 15:39:49 +02:00
|
|
|
if (!device || !path)
|
|
|
|
continue;
|
|
|
|
|
2015-04-06 20:11:41 +02:00
|
|
|
if (cunescape(device, UNESCAPE_RELAX, &d) < 0)
|
2015-02-27 21:55:08 +01:00
|
|
|
return log_oom();
|
|
|
|
|
2015-04-06 20:11:41 +02:00
|
|
|
if (cunescape(path, UNESCAPE_RELAX, &p) < 0)
|
2013-09-26 20:14:24 +02:00
|
|
|
return log_oom();
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2018-06-04 18:06:05 +02:00
|
|
|
device_found_node(m, d, DEVICE_FOUND_MOUNT, DEVICE_FOUND_MOUNT);
|
2015-02-27 21:55:08 +01:00
|
|
|
|
|
|
|
k = mount_setup_unit(m, d, p, options, fstype, set_flags);
|
2014-11-28 19:02:15 +01:00
|
|
|
if (r == 0 && k < 0)
|
2010-10-12 04:06:21 +02:00
|
|
|
r = k;
|
2010-01-29 02:07:41 +01:00
|
|
|
}
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mount_shutdown(Manager *m) {
|
|
|
|
assert(m);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
m->mount_event_source = sd_event_source_unref(m->mount_event_source);
|
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
mnt_unref_monitor(m->mount_monitor);
|
|
|
|
m->mount_monitor = NULL;
|
2010-01-29 02:07:41 +01:00
|
|
|
}
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
static int mount_get_timeout(Unit *u, usec_t *timeout) {
|
2014-01-27 06:57:34 +01:00
|
|
|
Mount *m = MOUNT(u);
|
2016-02-04 00:35:43 +01:00
|
|
|
usec_t t;
|
2014-01-27 06:57:34 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!m->timer_event_source)
|
|
|
|
return 0;
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
r = sd_event_source_get_time(m->timer_event_source, &t);
|
2014-01-27 06:57:34 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2016-02-04 00:35:43 +01:00
|
|
|
if (t == USEC_INFINITY)
|
|
|
|
return 0;
|
2014-01-27 06:57:34 +01:00
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
*timeout = t;
|
2014-01-27 06:57:34 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
core: enumerate perpetual units in a separate per-unit-type method
Previously the enumerate() callback defined for each unit type would do
two things:
1. It would create perpetual units (i.e. -.slice, system.slice, -.mount and
init.scope)
2. It would enumerate units from /proc/self/mountinfo, /proc/swaps and
the udev database
With this change these two parts are split into two seperate methods:
enumerate() now only does #2, while enumerate_perpetual() is responsible
for #1. Why make this change? Well, perpetual units should have a
slightly different effect that those found through enumeration: as
perpetual units should be up unconditionally, perpetually and thus never
change state, they should also not pull in deps by their state changing,
not even when the state is first set to active. Thus, their state is
generally initialized through the per-device coldplug() method in
similar fashion to the deserialized state from a previous run would be
put into place. OTOH units found through regular enumeration should
result in state changes (and thus pull in deps due to state changes),
hence their state should be put in effect in the catchup() method
instead. Hence, given this difference, let's also separate the
functions, so that the rule is:
1. What is created in enumerate_perpetual() should be started in
coldplug()
2. What is created in enumerate() should be started in catchup().
2018-06-05 18:26:45 +02:00
|
|
|
static void mount_enumerate_perpetual(Manager *m) {
|
2016-10-25 00:04:55 +02:00
|
|
|
Unit *u;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
/* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
|
|
|
|
* unconditionally synthesize it here and mark it as perpetual. */
|
|
|
|
|
|
|
|
u = manager_get_unit(m, SPECIAL_ROOT_MOUNT);
|
|
|
|
if (!u) {
|
2016-10-25 00:29:05 +02:00
|
|
|
r = unit_new_for_name(m, sizeof(Mount), SPECIAL_ROOT_MOUNT, &u);
|
core: enumerate perpetual units in a separate per-unit-type method
Previously the enumerate() callback defined for each unit type would do
two things:
1. It would create perpetual units (i.e. -.slice, system.slice, -.mount and
init.scope)
2. It would enumerate units from /proc/self/mountinfo, /proc/swaps and
the udev database
With this change these two parts are split into two seperate methods:
enumerate() now only does #2, while enumerate_perpetual() is responsible
for #1. Why make this change? Well, perpetual units should have a
slightly different effect that those found through enumeration: as
perpetual units should be up unconditionally, perpetually and thus never
change state, they should also not pull in deps by their state changing,
not even when the state is first set to active. Thus, their state is
generally initialized through the per-device coldplug() method in
similar fashion to the deserialized state from a previous run would be
put into place. OTOH units found through regular enumeration should
result in state changes (and thus pull in deps due to state changes),
hence their state should be put in effect in the catchup() method
instead. Hence, given this difference, let's also separate the
functions, so that the rule is:
1. What is created in enumerate_perpetual() should be started in
coldplug()
2. What is created in enumerate() should be started in catchup().
2018-06-05 18:26:45 +02:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
|
|
|
|
return;
|
|
|
|
}
|
2016-10-25 00:04:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
u->perpetual = true;
|
|
|
|
MOUNT(u)->deserialized_state = MOUNT_MOUNTED;
|
|
|
|
|
|
|
|
unit_add_to_load_queue(u);
|
|
|
|
unit_add_to_dbus_queue(u);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool mount_is_mounted(Mount *m) {
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
return UNIT(m)->perpetual || m->is_mounted;
|
|
|
|
}
|
|
|
|
|
2015-11-10 20:36:37 +01:00
|
|
|
static void mount_enumerate(Manager *m) {
|
2010-01-29 02:07:41 +01:00
|
|
|
int r;
|
2015-06-01 13:48:01 +02:00
|
|
|
|
2010-01-29 02:07:41 +01:00
|
|
|
assert(m);
|
|
|
|
|
2014-11-24 05:33:37 +01:00
|
|
|
mnt_init_debug(0);
|
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
if (!m->mount_monitor) {
|
|
|
|
int fd;
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
m->mount_monitor = mnt_new_monitor();
|
|
|
|
if (!m->mount_monitor) {
|
2015-11-10 20:36:37 +01:00
|
|
|
log_oom();
|
2013-11-19 21:12:59 +01:00
|
|
|
goto fail;
|
2015-06-01 13:48:01 +02:00
|
|
|
}
|
2013-11-25 15:35:10 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
r = mnt_monitor_enable_kernel(m->mount_monitor, 1);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to enable watching of kernel mount events: %m");
|
2013-11-25 15:35:10 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
r = mnt_monitor_enable_userspace(m->mount_monitor, 1, NULL);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to enable watching of userspace mount events: %m");
|
2014-12-10 01:45:43 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2014-11-28 19:43:09 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
/* mnt_unref_monitor() will close the fd */
|
|
|
|
fd = r = mnt_monitor_get_fd(m->mount_monitor);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to acquire watch file descriptor: %m");
|
2014-12-10 01:45:43 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2014-11-24 05:33:39 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
r = sd_event_add_io(m->event, &m->mount_event_source, fd, EPOLLIN, mount_dispatch_io, m);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to watch mount file descriptor: %m");
|
2014-11-24 05:33:39 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2014-11-24 05:33:39 +01:00
|
|
|
|
2018-01-23 18:13:01 +01:00
|
|
|
r = sd_event_source_set_priority(m->mount_event_source, SD_EVENT_PRIORITY_NORMAL-10);
|
2015-11-10 20:36:37 +01:00
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to adjust mount watch priority: %m");
|
2014-11-24 05:33:39 +01:00
|
|
|
goto fail;
|
2015-11-10 20:36:37 +01:00
|
|
|
}
|
2015-04-29 16:05:32 +02:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
(void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
|
2014-11-24 05:33:39 +01:00
|
|
|
}
|
|
|
|
|
2013-03-25 00:45:16 +01:00
|
|
|
r = mount_load_proc_self_mountinfo(m, false);
|
|
|
|
if (r < 0)
|
2010-01-29 02:07:41 +01:00
|
|
|
goto fail;
|
|
|
|
|
2015-11-10 20:36:37 +01:00
|
|
|
return;
|
2010-01-29 02:07:41 +01:00
|
|
|
|
|
|
|
fail:
|
|
|
|
mount_shutdown(m);
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
2015-05-19 13:50:36 +02:00
|
|
|
_cleanup_set_free_ Set *around = NULL, *gone = NULL;
|
2013-11-19 21:12:59 +01:00
|
|
|
Manager *m = userdata;
|
2015-05-19 13:50:36 +02:00
|
|
|
const char *what;
|
|
|
|
Iterator i;
|
2012-01-15 12:37:16 +01:00
|
|
|
Unit *u;
|
2010-01-29 06:04:08 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(m);
|
2015-06-01 13:48:01 +02:00
|
|
|
assert(revents & EPOLLIN);
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
if (fd == mnt_monitor_get_fd(m->mount_monitor)) {
|
2014-12-10 00:52:56 +01:00
|
|
|
bool rescan = false;
|
2014-11-24 05:33:39 +01:00
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
/* Drain all events and verify that the event is valid.
|
|
|
|
*
|
|
|
|
* Note that libmount also monitors /run/mount mkdir if the
|
|
|
|
* directory does not exist yet. The mkdir may generate event
|
|
|
|
* which is irrelevant for us.
|
|
|
|
*
|
|
|
|
* error: r < 0; valid: r == 0, false positive: rc == 1 */
|
|
|
|
do {
|
|
|
|
r = mnt_monitor_next_change(m->mount_monitor, NULL, NULL);
|
|
|
|
if (r == 0)
|
|
|
|
rescan = true;
|
|
|
|
else if (r < 0)
|
2018-10-19 18:40:42 +02:00
|
|
|
return log_error_errno(r, "Failed to drain libmount events: %m");
|
2015-06-01 13:48:01 +02:00
|
|
|
} while (r == 0);
|
|
|
|
|
|
|
|
log_debug("libmount event [rescan: %s]", yes_no(rescan));
|
2014-11-24 05:33:39 +01:00
|
|
|
if (!rescan)
|
|
|
|
return 0;
|
|
|
|
}
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2013-01-04 21:29:48 +01:00
|
|
|
r = mount_load_proc_self_mountinfo(m, true);
|
|
|
|
if (r < 0) {
|
2010-04-10 17:53:17 +02:00
|
|
|
/* Reset flags, just in case, for later calls */
|
2012-01-15 12:37:16 +01:00
|
|
|
LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
|
|
|
|
Mount *mount = MOUNT(u);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
mount->is_mounted = mount->just_mounted = mount->just_changed = false;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-01-29 06:04:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
manager_dispatch_load_queue(m);
|
|
|
|
|
2012-01-15 12:37:16 +01:00
|
|
|
LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
|
|
|
|
Mount *mount = MOUNT(u);
|
2010-01-29 06:04:08 +01:00
|
|
|
|
2016-10-25 00:04:55 +02:00
|
|
|
if (!mount_is_mounted(mount)) {
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2015-05-19 17:19:27 +02:00
|
|
|
/* A mount point is not around right now. It
|
|
|
|
* might be gone, or might never have
|
|
|
|
* existed. */
|
|
|
|
|
|
|
|
if (mount->from_proc_self_mountinfo &&
|
|
|
|
mount->parameters_proc_self_mountinfo.what) {
|
|
|
|
|
|
|
|
/* Remember that this device might just have disappeared */
|
2018-02-08 18:58:35 +01:00
|
|
|
if (set_ensure_allocated(&gone, &path_hash_ops) < 0 ||
|
2015-05-19 17:19:27 +02:00
|
|
|
set_put(gone, mount->parameters_proc_self_mountinfo.what) < 0)
|
|
|
|
log_oom(); /* we don't care too much about OOM here... */
|
|
|
|
}
|
2015-05-19 13:50:36 +02:00
|
|
|
|
2010-01-29 06:04:08 +01:00
|
|
|
mount->from_proc_self_mountinfo = false;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
switch (mount->state) {
|
|
|
|
|
|
|
|
case MOUNT_MOUNTED:
|
2014-02-26 04:28:37 +01:00
|
|
|
/* This has just been unmounted by
|
|
|
|
* somebody else, follow the state
|
|
|
|
* change. */
|
2016-06-06 22:03:31 +02:00
|
|
|
mount->result = MOUNT_SUCCESS; /* make sure we forget any earlier umount failures */
|
2012-02-03 03:10:56 +01:00
|
|
|
mount_enter_dead(mount, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (mount->just_mounted || mount->just_changed) {
|
|
|
|
|
2015-05-19 13:50:36 +02:00
|
|
|
/* A mount point was added or changed */
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
switch (mount->state) {
|
|
|
|
|
|
|
|
case MOUNT_DEAD:
|
2010-08-31 00:23:34 +02:00
|
|
|
case MOUNT_FAILED:
|
2016-08-30 23:18:46 +02:00
|
|
|
|
|
|
|
/* This has just been mounted by somebody else, follow the state change, but let's
|
|
|
|
* generate a new invocation ID for this implicitly and automatically. */
|
|
|
|
(void) unit_acquire_invocation_id(UNIT(mount));
|
2012-02-03 03:10:56 +01:00
|
|
|
mount_enter_mounted(mount, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING:
|
2013-11-25 15:26:30 +01:00
|
|
|
mount_set_state(mount, MOUNT_MOUNTING_DONE);
|
2010-04-10 17:53:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* Nothing really changed, but let's
|
|
|
|
* issue an notification call
|
|
|
|
* nonetheless, in case somebody is
|
|
|
|
* waiting for this. (e.g. file system
|
|
|
|
* ro/rw remounts.) */
|
|
|
|
mount_set_state(mount, mount->state);
|
|
|
|
break;
|
|
|
|
}
|
2015-05-19 17:19:27 +02:00
|
|
|
}
|
2015-05-19 13:50:36 +02:00
|
|
|
|
2016-10-25 00:04:55 +02:00
|
|
|
if (mount_is_mounted(mount) &&
|
2015-05-19 17:19:27 +02:00
|
|
|
mount->from_proc_self_mountinfo &&
|
|
|
|
mount->parameters_proc_self_mountinfo.what) {
|
2015-05-19 13:50:36 +02:00
|
|
|
|
2018-02-08 18:58:35 +01:00
|
|
|
if (set_ensure_allocated(&around, &path_hash_ops) < 0 ||
|
2015-05-19 17:19:27 +02:00
|
|
|
set_put(around, mount->parameters_proc_self_mountinfo.what) < 0)
|
|
|
|
log_oom();
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the flags for later calls */
|
|
|
|
mount->is_mounted = mount->just_mounted = mount->just_changed = false;
|
|
|
|
}
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2015-05-19 13:50:36 +02:00
|
|
|
SET_FOREACH(what, gone, i) {
|
|
|
|
if (set_contains(around, what))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Let the device units know that the device is no longer mounted */
|
2018-06-04 18:06:05 +02:00
|
|
|
device_found_node(m, what, 0, DEVICE_FOUND_MOUNT);
|
2015-05-19 13:50:36 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
return 0;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
static void mount_reset_failed(Unit *u) {
|
2010-07-18 04:58:01 +02:00
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
if (m->state == MOUNT_FAILED)
|
2010-07-18 04:58:01 +02:00
|
|
|
mount_set_state(m, MOUNT_DEAD);
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
m->result = MOUNT_SUCCESS;
|
|
|
|
m->reload_result = MOUNT_SUCCESS;
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
|
mount: rework mount state engine
This changes the mount unit state engine in the following ways:
1. The MOUNT_MOUNTING_SIGTERM and MOUNT_MOUNTING_SIGKILL are removed.
They have been pretty much equivalent to MOUNT_UNMOUNTING_SIGTERM and
MOUNT_UNMOUNTING_SIGKILL in what they do, and the outcome has been
the same as well: the unit is stopped. Hence, let's simplify things a
bit, and merge them. Note that we keep
MOUNT_REMOUNTING_{SIGTERM|SIGKILL} however, as those states have a
different outcome: the unit remains started.
2. mount_enter_signal() will now honour the SendSIGKILL= option of the
mount unit if it was set. This was previously done already when we
entered the signal states through a timeout, and was simply missing
here.
3. A new helper function mount_enter_dead_or_mounted() is added that
places the mount unit in either MOUNT_DEAD or MOUNT_MOUNTED,
depending on what the kernel thinks about the mount's state. This
function is called at various places now, wherever we finished an
operation, and want to make sure our own state reflects again what
the kernel thinks. Previously we had very similar code in a number of
places and in other places didn't recheck the kernel state. Let's do
that with the same logic and function at all relevant places now.
4. Rework mount_stop(): never forget about running control processes.
Instead: when we have a start (i.e. a /bin/mount) process running,
and are asked to stop, then enter the kill states for it, so that it
gets cleaned up. This fixes #6048. Moreover, when we have a reload
process running convert the possible states into the relevant
unmounting states, so that we can properly execute the requested
operation.
Fixes #6048
2017-09-25 19:13:37 +02:00
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
2013-03-02 22:31:09 +01:00
|
|
|
return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
|
2010-10-22 16:11:50 +02:00
|
|
|
}
|
|
|
|
|
2016-04-20 15:28:28 +02:00
|
|
|
static int mount_control_pid(Unit *u) {
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
return m->control_pid;
|
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
|
|
|
|
[MOUNT_EXEC_MOUNT] = "ExecMount",
|
|
|
|
[MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
|
|
|
|
[MOUNT_EXEC_REMOUNT] = "ExecRemount",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
|
|
|
|
[MOUNT_SUCCESS] = "success",
|
|
|
|
[MOUNT_FAILURE_RESOURCES] = "resources",
|
|
|
|
[MOUNT_FAILURE_TIMEOUT] = "timeout",
|
|
|
|
[MOUNT_FAILURE_EXIT_CODE] = "exit-code",
|
|
|
|
[MOUNT_FAILURE_SIGNAL] = "signal",
|
core: move enforcement of the start limit into per-unit-type code again
Let's move the enforcement of the per-unit start limit from unit.c into the
type-specific files again. For unit types that know a concept of "result" codes
this allows us to hook up the start limit condition to it with an explicit
result code. Also, this makes sure that the state checks in clal like
service_start() may be done before the start limit is checked, as the start
limit really should be checked last, right before everything has been verified
to be in order.
The generic start limit logic is left in unit.c, but the invocation of it is
moved into the per-type files, in the various xyz_start() functions, so that
they may place the check at the right location.
Note that this change drops the enforcement entirely from device, slice, target
and scope units, since these unit types generally may not fail activation, or
may only be activated a single time. This is also documented now.
Note that restores the "start-limit-hit" result code that existed before
6bf0f408e4833152197fb38fb10a9989c89f3a59 already in the service code. However,
it's not introduced for all units that have a result code concept.
Fixes #3166.
2016-05-02 13:01:26 +02:00
|
|
|
[MOUNT_FAILURE_CORE_DUMP] = "core-dump",
|
|
|
|
[MOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
|
2018-01-20 21:05:52 +01:00
|
|
|
[MOUNT_FAILURE_PROTOCOL] = "protocol",
|
2012-02-03 03:10:56 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
const UnitVTable mount_vtable = {
|
2012-01-15 10:53:49 +01:00
|
|
|
.object_size = sizeof(Mount),
|
2013-11-19 21:12:59 +01:00
|
|
|
.exec_context_offset = offsetof(Mount, exec_context),
|
|
|
|
.cgroup_context_offset = offsetof(Mount, cgroup_context),
|
|
|
|
.kill_context_offset = offsetof(Mount, kill_context),
|
2013-11-27 20:23:18 +01:00
|
|
|
.exec_runtime_offset = offsetof(Mount, exec_runtime),
|
2016-07-14 12:37:28 +02:00
|
|
|
.dynamic_creds_offset = offsetof(Mount, dynamic_creds),
|
2012-09-18 11:40:01 +02:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
.sections =
|
|
|
|
"Unit\0"
|
|
|
|
"Mount\0"
|
|
|
|
"Install\0",
|
2013-06-27 04:14:27 +02:00
|
|
|
.private_section = "Mount",
|
2013-01-19 01:01:41 +01:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
.init = mount_init,
|
|
|
|
.load = mount_load,
|
2010-01-26 04:18:44 +01:00
|
|
|
.done = mount_done,
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
.coldplug = mount_coldplug,
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
.dump = mount_dump,
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
.start = mount_start,
|
|
|
|
.stop = mount_stop,
|
|
|
|
.reload = mount_reload,
|
|
|
|
|
2010-10-22 16:11:50 +02:00
|
|
|
.kill = mount_kill,
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
.serialize = mount_serialize,
|
|
|
|
.deserialize_item = mount_deserialize_item,
|
|
|
|
|
2010-01-29 03:18:09 +01:00
|
|
|
.active_state = mount_active_state,
|
2010-04-13 20:59:01 +02:00
|
|
|
.sub_state_to_string = mount_sub_state_to_string,
|
2010-01-29 02:07:41 +01:00
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
.may_gc = mount_may_gc,
|
2010-04-21 06:01:13 +02:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
.sigchld_event = mount_sigchld_event,
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
.reset_failed = mount_reset_failed,
|
2016-04-20 15:28:28 +02:00
|
|
|
|
|
|
|
.control_pid = mount_control_pid,
|
2010-07-18 04:58:01 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
.bus_vtable = bus_mount_vtable,
|
2013-06-27 23:21:21 +02:00
|
|
|
.bus_set_property = bus_mount_set_property,
|
|
|
|
.bus_commit_properties = bus_mount_commit_properties,
|
2010-04-18 03:08:16 +02:00
|
|
|
|
2014-01-27 06:57:34 +01:00
|
|
|
.get_timeout = mount_get_timeout,
|
|
|
|
|
2014-06-06 15:10:20 +02:00
|
|
|
.can_transient = true,
|
|
|
|
|
core: enumerate perpetual units in a separate per-unit-type method
Previously the enumerate() callback defined for each unit type would do
two things:
1. It would create perpetual units (i.e. -.slice, system.slice, -.mount and
init.scope)
2. It would enumerate units from /proc/self/mountinfo, /proc/swaps and
the udev database
With this change these two parts are split into two seperate methods:
enumerate() now only does #2, while enumerate_perpetual() is responsible
for #1. Why make this change? Well, perpetual units should have a
slightly different effect that those found through enumeration: as
perpetual units should be up unconditionally, perpetually and thus never
change state, they should also not pull in deps by their state changing,
not even when the state is first set to active. Thus, their state is
generally initialized through the per-device coldplug() method in
similar fashion to the deserialized state from a previous run would be
put into place. OTOH units found through regular enumeration should
result in state changes (and thus pull in deps due to state changes),
hence their state should be put in effect in the catchup() method
instead. Hence, given this difference, let's also separate the
functions, so that the rule is:
1. What is created in enumerate_perpetual() should be started in
coldplug()
2. What is created in enumerate() should be started in catchup().
2018-06-05 18:26:45 +02:00
|
|
|
.enumerate_perpetual = mount_enumerate_perpetual,
|
2010-01-29 03:18:09 +01:00
|
|
|
.enumerate = mount_enumerate,
|
2012-05-13 18:18:54 +02:00
|
|
|
.shutdown = mount_shutdown,
|
|
|
|
|
|
|
|
.status_message_formats = {
|
|
|
|
.starting_stopping = {
|
|
|
|
[0] = "Mounting %s...",
|
|
|
|
[1] = "Unmounting %s...",
|
|
|
|
},
|
|
|
|
.finished_start_job = {
|
|
|
|
[JOB_DONE] = "Mounted %s.",
|
|
|
|
[JOB_FAILED] = "Failed to mount %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out mounting %s.",
|
|
|
|
},
|
|
|
|
.finished_stop_job = {
|
|
|
|
[JOB_DONE] = "Unmounted %s.",
|
|
|
|
[JOB_FAILED] = "Failed unmounting %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out unmounting %s.",
|
|
|
|
},
|
|
|
|
},
|
2010-01-23 01:52:57 +01:00
|
|
|
};
|