2010-02-03 13:03:47 +01:00
|
|
|
|
/***
|
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
2012-04-12 00:20:58 +02:00
|
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-02-03 13:03:47 +01:00
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2012-04-12 00:20:58 +02:00
|
|
|
|
Lesser General Public License for more details.
|
2010-02-03 13:03:47 +01:00
|
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-02-03 13:03:47 +01:00
|
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
***/
|
|
|
|
|
|
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
|
|
|
|
|
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"
|
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"
|
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,
|
2010-04-10 17:53:17 +02:00
|
|
|
|
[MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
|
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-04-10 17:53:17 +02:00
|
|
|
|
[MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
|
|
|
|
|
[MOUNT_MOUNTING_SIGKILL] = 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);
|
|
|
|
|
|
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-05-03 21:57:36 +02:00
|
|
|
|
static bool mount_state_active(MountState state) {
|
|
|
|
|
return IN_SET(state,
|
|
|
|
|
MOUNT_MOUNTING,
|
|
|
|
|
MOUNT_MOUNTING_DONE,
|
|
|
|
|
MOUNT_REMOUNTING,
|
|
|
|
|
MOUNT_UNMOUNTING,
|
|
|
|
|
MOUNT_MOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_MOUNTING_SIGKILL,
|
|
|
|
|
MOUNT_UNMOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_UNMOUNTING_SIGKILL,
|
|
|
|
|
MOUNT_REMOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_REMOUNTING_SIGKILL);
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
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
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
|
m->exec_runtime = exec_runtime_unref(m->exec_runtime);
|
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
|
|
|
|
}
|
|
|
|
|
|
2010-05-13 03:07:16 +02:00
|
|
|
|
static int mount_add_mount_links(Mount *m) {
|
2013-09-26 20:14:24 +02:00
|
|
|
|
_cleanup_free_ char *parent = NULL;
|
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, "/")) {
|
|
|
|
|
/* 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
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
|
r = unit_require_mounts_for(UNIT(m), parent);
|
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
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
|
/* Adds in links to other mount points that might be needed
|
2016-04-25 13:25:00 +02:00
|
|
|
|
* for the source path (if this is a bind mount or a loop mount) to be
|
2013-09-26 20:14:24 +02:00
|
|
|
|
* available. */
|
|
|
|
|
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
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
|
r = unit_require_mounts_for(UNIT(m), pm->what);
|
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
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
|
/* Adds in links to other units that use this path or paths
|
|
|
|
|
* further down in the hierarchy */
|
|
|
|
|
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
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
|
r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
|
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 */
|
|
|
|
|
r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
|
|
|
|
}
|
2012-04-29 14:26:07 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-25 20:37:04 +02:00
|
|
|
|
static int mount_add_device_links(Mount *m) {
|
|
|
|
|
MountParameters *p;
|
2013-08-19 11:45:24 +02:00
|
|
|
|
bool device_wants_mount = false;
|
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;
|
|
|
|
|
|
|
|
|
|
r = unit_add_node_link(UNIT(m), p->what, device_wants_mount, dep);
|
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
|
|
|
|
}
|
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
|
static int mount_add_quota_links(Mount *m) {
|
|
|
|
|
int r;
|
|
|
|
|
MountParameters *p;
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
|
|
|
|
|
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) {
|
2012-01-13 23:55:28 +01:00
|
|
|
|
MountParameters *p;
|
2015-11-11 20:46:09 +01:00
|
|
|
|
const char *after;
|
2013-03-28 21:18:58 +01:00
|
|
|
|
int r;
|
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;
|
|
|
|
|
|
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
|
|
|
|
|
2015-11-11 20:46:09 +01:00
|
|
|
|
r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, SPECIAL_NETWORK_TARGET, NULL, true);
|
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". */
|
|
|
|
|
|
|
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, SPECIAL_NETWORK_ONLINE_TARGET, NULL, true);
|
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;
|
|
|
|
|
|
|
|
|
|
r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
2013-03-25 22:04:40 +01:00
|
|
|
|
|
2016-11-29 22:50:21 +01:00
|
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
|
|
|
|
|
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;
|
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
|
if (!m->from_fragment && !m->from_proc_self_mountinfo)
|
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.");
|
2010-04-16 23:24:39 +02:00
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
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);
|
2011-04-05 23:39:21 +02:00
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
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.");
|
2010-05-14 02:29:45 +02:00
|
|
|
|
return -EBADMSG;
|
|
|
|
|
}
|
|
|
|
|
|
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.");
|
2010-06-19 16:57:54 +02:00
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
|
path_kill_slashes(m->where);
|
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
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
|
r = mount_add_device_links(m);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
|
r = mount_add_mount_links(m);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
|
2012-06-29 01:47:24 +02:00
|
|
|
|
r = mount_add_quota_links(m);
|
|
|
|
|
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;
|
|
|
|
|
|
2016-05-03 21:57:36 +02:00
|
|
|
|
if (!mount_state_active(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
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
|
unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
|
|
|
|
|
m->reload_result = MOUNT_SUCCESS;
|
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) &&
|
2016-05-03 21:57:36 +02:00
|
|
|
|
mount_state_active(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
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
|
if (!IN_SET(new_state, MOUNT_DEAD, MOUNT_FAILED))
|
|
|
|
|
(void) unit_setup_dynamic_creds(u);
|
|
|
|
|
|
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) {
|
|
|
|
|
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"
|
|
|
|
|
"%sForceUnmount: %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),
|
|
|
|
|
prefix, yes_no(m->force_unmount));
|
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);
|
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) {
|
|
|
|
|
pid_t pid;
|
|
|
|
|
int r;
|
2014-08-23 15:28:37 +02:00
|
|
|
|
ExecParameters exec_params = {
|
2016-07-26 17:40:35 +02:00
|
|
|
|
.flags = EXEC_APPLY_PERMISSIONS|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
|
|
|
|
|
.stdin_fd = -1,
|
|
|
|
|
.stdout_fd = -1,
|
|
|
|
|
.stderr_fd = -1,
|
2014-08-23 15:28:37 +02:00
|
|
|
|
};
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
assert(c);
|
|
|
|
|
assert(_pid);
|
|
|
|
|
|
2015-03-01 16:24:19 +01:00
|
|
|
|
(void) unit_realize_cgroup(UNIT(m));
|
|
|
|
|
if (m->reset_cpu_usage) {
|
|
|
|
|
(void) unit_reset_cpu_usage(UNIT(m));
|
|
|
|
|
m->reset_cpu_usage = false;
|
|
|
|
|
}
|
2013-06-27 04:14:27 +02:00
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
|
r = unit_setup_exec_runtime(UNIT(m));
|
|
|
|
|
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;
|
2013-11-27 20:23:18 +01:00
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
|
r = unit_setup_dynamic_creds(UNIT(m));
|
|
|
|
|
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
|
|
|
|
|
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
|
|
|
|
r = manager_set_exec_params(UNIT(m)->manager, &exec_params);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
|
|
|
|
|
2014-08-23 15:28:37 +02:00
|
|
|
|
exec_params.cgroup_path = UNIT(m)->cgroup_path;
|
2014-11-05 17:57:23 +01:00
|
|
|
|
exec_params.cgroup_delegate = m->cgroup_context.delegate;
|
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
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
|
mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
|
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
|
exec_runtime_destroy(m->exec_runtime);
|
|
|
|
|
m->exec_runtime = exec_runtime_unref(m->exec_runtime);
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
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,
|
2014-10-28 16:35:40 +01:00
|
|
|
|
(state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
|
|
|
|
|
KILL_KILL : KILL_TERMINATE,
|
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);
|
2014-01-29 14:58:04 +01:00
|
|
|
|
} else if (state == MOUNT_REMOUNTING_SIGTERM)
|
|
|
|
|
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
|
|
|
|
|
else if (state == MOUNT_REMOUNTING_SIGKILL)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_SUCCESS);
|
2014-01-29 14:58:04 +01:00
|
|
|
|
else if (state == MOUNT_MOUNTING_SIGTERM)
|
|
|
|
|
mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
|
|
|
|
|
else if (state == MOUNT_UNMOUNTING_SIGTERM)
|
|
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
|
2010-04-13 02:06:27 +02:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(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");
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
2016-10-10 22:28:38 +02:00
|
|
|
|
if (IN_SET(state, MOUNT_REMOUNTING_SIGTERM, MOUNT_REMOUNTING_SIGKILL))
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
|
2010-04-13 02:06:27 +02:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(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");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_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);
|
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
|
m->control_command_id = MOUNT_EXEC_MOUNT;
|
|
|
|
|
m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
|
2010-04-10 17:53:17 +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 = unit_fail_if_symlink(UNIT(m), m->where);
|
|
|
|
|
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
|
|
|
|
|
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");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
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);
|
|
|
|
|
|
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");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
m->reload_result = MOUNT_FAILURE_RESOURCES;
|
|
|
|
|
mount_enter_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_UNMOUNTING_SIGKILL,
|
|
|
|
|
MOUNT_MOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_MOUNTING_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;
|
2015-03-01 16:24:19 +01:00
|
|
|
|
m->reset_cpu_usage = 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);
|
|
|
|
|
|
|
|
|
|
/* Already on it */
|
2016-10-10 22:28:38 +02:00
|
|
|
|
if (IN_SET(m->state,
|
|
|
|
|
MOUNT_UNMOUNTING,
|
|
|
|
|
MOUNT_UNMOUNTING_SIGKILL,
|
|
|
|
|
MOUNT_UNMOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_MOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_MOUNTING_SIGKILL))
|
2010-04-10 17:53:17 +02:00
|
|
|
|
return 0;
|
|
|
|
|
|
2016-10-10 22:28:38 +02:00
|
|
|
|
assert(IN_SET(m->state,
|
|
|
|
|
MOUNT_MOUNTING,
|
|
|
|
|
MOUNT_MOUNTING_DONE,
|
|
|
|
|
MOUNT_MOUNTED,
|
|
|
|
|
MOUNT_REMOUNTING,
|
|
|
|
|
MOUNT_REMOUNTING_SIGTERM,
|
|
|
|
|
MOUNT_REMOUNTING_SIGKILL));
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_unmounting(m);
|
2015-01-28 15:07:13 +01:00
|
|
|
|
return 1;
|
2010-04-10 17:53:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mount_reload(Unit *u) {
|
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
|
|
|
|
if (m->state == MOUNT_MOUNTING_DONE)
|
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
|
|
assert(m->state == MOUNT_MOUNTED);
|
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_remounting(m);
|
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);
|
|
|
|
|
|
|
|
|
|
unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
|
2012-02-03 03:10:56 +01:00
|
|
|
|
unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
|
|
|
|
|
unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
|
|
if (m->control_pid > 0)
|
2013-12-30 23:22:26 +01:00
|
|
|
|
unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
|
|
if (m->control_command_id >= 0)
|
|
|
|
|
unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
|
_pure_ static bool mount_check_gc(Unit *u) {
|
2010-04-21 06:01:13 +02:00
|
|
|
|
Mount *m = MOUNT(u);
|
|
|
|
|
|
|
|
|
|
assert(m);
|
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
|
return m->from_proc_self_mountinfo;
|
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");
|
|
|
|
|
|
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-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;
|
|
|
|
|
}
|
|
|
|
|
|
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_full(u, f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
|
|
|
|
|
"Mount process exited, code=%s status=%i", sigchld_code_to_string(code), status);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
|
|
/* Note that mount(8) returning and the kernel sending us a
|
|
|
|
|
* mount table change event might happen out-of-order. If an
|
|
|
|
|
* operation succeed we assume the kernel will follow soon too
|
|
|
|
|
* and already change into the resulting state. If it fails
|
|
|
|
|
* we check if the kernel still knows about the mount. and
|
|
|
|
|
* change state accordingly. */
|
|
|
|
|
|
|
|
|
|
switch (m->state) {
|
|
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING:
|
|
|
|
|
case MOUNT_MOUNTING_DONE:
|
|
|
|
|
case MOUNT_MOUNTING_SIGKILL:
|
|
|
|
|
case MOUNT_MOUNTING_SIGTERM:
|
|
|
|
|
|
2016-10-10 22:28:55 +02:00
|
|
|
|
if (f == MOUNT_SUCCESS || m->from_proc_self_mountinfo)
|
|
|
|
|
/* If /bin/mount returned success, or if we see the mount point in /proc/self/mountinfo we are
|
2017-02-02 17:18:34 +01:00
|
|
|
|
* happy. If we see the first condition first, we should see the second condition
|
2016-10-10 22:28:55 +02:00
|
|
|
|
* immediately after – or /bin/mount lies to us and is broken. */
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, f);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(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_SIGKILL:
|
|
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
|
|
|
|
|
2012-02-03 03:10:56 +01:00
|
|
|
|
m->reload_result = f;
|
2011-01-20 13:17:22 +01:00
|
|
|
|
if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_SUCCESS);
|
2011-01-20 13:17:22 +01:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, MOUNT_SUCCESS);
|
2011-01-20 13:17:22 +01:00
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
|
case MOUNT_UNMOUNTING:
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGTERM:
|
|
|
|
|
|
2014-12-12 20:12:35 +01:00
|
|
|
|
if (f == MOUNT_SUCCESS) {
|
|
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo) {
|
|
|
|
|
|
|
|
|
|
/* Still a mount point? If so, let's
|
|
|
|
|
* try again. Most likely there were
|
|
|
|
|
* multiple mount points stacked on
|
|
|
|
|
* top of each other. 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. */
|
|
|
|
|
|
|
|
|
|
if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
|
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, "Mount still present, trying again.");
|
2014-12-12 20:12:35 +01:00
|
|
|
|
m->n_retry_umount++;
|
|
|
|
|
mount_enter_unmounting(m);
|
|
|
|
|
} 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, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
|
2014-12-12 20:12:35 +01:00
|
|
|
|
mount_enter_mounted(m, f);
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
mount_enter_dead(m, f);
|
|
|
|
|
|
|
|
|
|
} else if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, f);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, f);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
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:
|
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(UNIT(m), "Mounting timed out. Stopping.");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING:
|
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(UNIT(m), "Remounting timed out. Stopping.");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
m->reload_result = MOUNT_FAILURE_TIMEOUT;
|
|
|
|
|
mount_enter_mounted(m, MOUNT_SUCCESS);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MOUNT_UNMOUNTING:
|
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(UNIT(m), "Unmounting timed out. Stopping.");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
|
if (m->kill_context.send_sigkill) {
|
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(UNIT(m), "Mounting timed out. Killing.");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
} 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_warning(UNIT(m), "Mounting timed out. Skipping SIGKILL. Ignoring.");
|
2011-01-18 22:55:54 +01:00
|
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MOUNT_REMOUNTING_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
|
if (m->kill_context.send_sigkill) {
|
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(UNIT(m), "Remounting timed out. Killing.");
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
} 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_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
|
2011-01-18 22:55:54 +01:00
|
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
}
|
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) {
|
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(UNIT(m), "Unmounting 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 {
|
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(UNIT(m), "Unmounting timed out. Skipping SIGKILL. Ignoring.");
|
2011-01-18 22:55:54 +01:00
|
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case MOUNT_MOUNTING_SIGKILL:
|
|
|
|
|
case MOUNT_REMOUNTING_SIGKILL:
|
|
|
|
|
case MOUNT_UNMOUNTING_SIGKILL:
|
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(UNIT(m),"Mount process still around after SIGKILL. Ignoring.");
|
2010-04-10 17:53:17 +02:00
|
|
|
|
|
|
|
|
|
if (m->from_proc_self_mountinfo)
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
|
2010-04-10 17:53:17 +02:00
|
|
|
|
else
|
2012-02-03 03:10:56 +01:00
|
|
|
|
mount_enter_dead(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;
|
|
|
|
|
r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
|
|
r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
|
|
|
|
|
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;
|
|
|
|
|
flags->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
|
|
|
|
|
|
|
|
|
|
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. */
|
|
|
|
|
unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true);
|
|
|
|
|
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:
|
2015-02-27 21:55:08 +01:00
|
|
|
|
log_warning_errno(r, "Failed to set up mount unit: %m");
|
2010-05-14 02:29:45 +02:00
|
|
|
|
return r;
|
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();
|
|
|
|
|
if (!t)
|
2014-11-24 05:33:37 +01:00
|
|
|
|
return log_oom();
|
2010-01-29 02:07:41 +01:00
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
|
i = mnt_new_iter(MNT_ITER_FORWARD);
|
|
|
|
|
if (!i)
|
|
|
|
|
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 (;;) {
|
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;
|
2015-02-27 21:55:08 +01:00
|
|
|
|
struct libmnt_fs *fs;
|
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
|
|
|
|
|
2015-02-27 21:55:08 +01:00
|
|
|
|
(void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
|
|
|
|
|
|
|
|
|
|
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) {
|
2015-06-01 13:48:01 +02:00
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2016-11-02 18:38:12 +01:00
|
|
|
|
static int synthesize_root_mount(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);
|
2016-11-02 18:38:12 +01:00
|
|
|
|
if (r < 0)
|
|
|
|
|
return log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_MOUNT " unit: %m");
|
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);
|
2016-11-02 18:38:12 +01:00
|
|
|
|
|
|
|
|
|
return 0;
|
2016-10-25 00:04:55 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
2016-11-02 18:38:12 +01:00
|
|
|
|
r = synthesize_root_mount(m);
|
|
|
|
|
if (r < 0)
|
|
|
|
|
goto fail;
|
2016-10-25 00:04:55 +02:00
|
|
|
|
|
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
|
|
|
|
|
2015-06-01 13:48:01 +02:00
|
|
|
|
r = sd_event_source_set_priority(m->mount_event_source, -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)
|
|
|
|
|
return log_error_errno(r, "Failed to drain libmount events");
|
|
|
|
|
} 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 */
|
|
|
|
|
if (set_ensure_allocated(&gone, &string_hash_ops) < 0 ||
|
|
|
|
|
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
|
|
|
|
|
2015-05-19 17:19:27 +02:00
|
|
|
|
if (set_ensure_allocated(&around, &string_hash_ops) < 0 ||
|
|
|
|
|
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 */
|
|
|
|
|
(void) device_found_node(m, what, false, DEVICE_FOUND_MOUNT, true);
|
|
|
|
|
}
|
|
|
|
|
|
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) {
|
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",
|
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
|
|
|
|
|
2010-04-21 06:01:13 +02:00
|
|
|
|
.check_gc = mount_check_gc,
|
|
|
|
|
|
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,
|
|
|
|
|
|
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
|
|
|
|
};
|