2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2010-02-03 13:03:47 +01:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
#include <arpa/inet.h>
|
2010-01-23 22:56:47 +01:00
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
2011-05-17 19:37:03 +02:00
|
|
|
#include <mqueue.h>
|
2015-09-23 19:52:23 +02:00
|
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/epoll.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2015-12-31 07:35:57 +01:00
|
|
|
#include <linux/sctp.h>
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2017-09-07 11:17:43 +02:00
|
|
|
#include "bpf-firewall.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "bus-error.h"
|
|
|
|
#include "bus-util.h"
|
|
|
|
#include "copy.h"
|
|
|
|
#include "dbus-socket.h"
|
|
|
|
#include "def.h"
|
|
|
|
#include "exit-status.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "fd-util.h"
|
2016-11-07 16:14:59 +01:00
|
|
|
#include "format-util.h"
|
2017-09-26 18:27:09 +02:00
|
|
|
#include "fs-util.h"
|
2017-09-07 11:17:43 +02:00
|
|
|
#include "in-addr-util.h"
|
2016-05-06 13:29:26 +02:00
|
|
|
#include "io-util.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "label.h"
|
2010-01-23 22:56:47 +01:00
|
|
|
#include "log.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "missing.h"
|
2012-04-10 21:54:31 +02:00
|
|
|
#include "mkdir.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2012-05-07 21:36:12 +02:00
|
|
|
#include "path-util.h"
|
2015-10-27 14:24:58 +01:00
|
|
|
#include "process-util.h"
|
2014-12-27 18:46:36 +01:00
|
|
|
#include "selinux-util.h"
|
2015-05-29 20:14:11 +02:00
|
|
|
#include "signal-util.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "smack-util.h"
|
2015-05-29 20:14:11 +02:00
|
|
|
#include "socket.h"
|
2017-12-23 11:32:04 +01:00
|
|
|
#include "socket-protocol-list.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "special.h"
|
2015-10-26 22:31:05 +01:00
|
|
|
#include "string-table.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "string-util.h"
|
2015-09-23 19:52:23 +02:00
|
|
|
#include "strv.h"
|
|
|
|
#include "unit-name.h"
|
|
|
|
#include "unit.h"
|
2015-10-25 22:32:30 +01:00
|
|
|
#include "user-util.h"
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2016-08-05 03:42:23 +02:00
|
|
|
struct SocketPeer {
|
|
|
|
unsigned n_ref;
|
|
|
|
|
|
|
|
Socket *socket;
|
|
|
|
union sockaddr_union peer;
|
2016-12-29 11:21:37 +01:00
|
|
|
socklen_t peer_salen;
|
2016-08-05 03:42:23 +02:00
|
|
|
};
|
|
|
|
|
2010-01-27 04:31:52 +01:00
|
|
|
static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
|
2010-01-26 21:39:06 +01:00
|
|
|
[SOCKET_DEAD] = UNIT_INACTIVE,
|
|
|
|
[SOCKET_START_PRE] = UNIT_ACTIVATING,
|
2014-06-05 09:55:53 +02:00
|
|
|
[SOCKET_START_CHOWN] = UNIT_ACTIVATING,
|
2010-01-26 21:39:06 +01:00
|
|
|
[SOCKET_START_POST] = UNIT_ACTIVATING,
|
|
|
|
[SOCKET_LISTENING] = UNIT_ACTIVE,
|
|
|
|
[SOCKET_RUNNING] = UNIT_ACTIVE,
|
|
|
|
[SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
|
|
|
|
[SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
|
|
|
|
[SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
|
|
|
|
[SOCKET_STOP_POST] = UNIT_DEACTIVATING,
|
2010-04-13 02:06:27 +02:00
|
|
|
[SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
|
|
|
|
[SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
|
2010-08-31 00:23:34 +02:00
|
|
|
[SOCKET_FAILED] = UNIT_FAILED
|
2010-01-23 22:56:47 +01:00
|
|
|
};
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
|
|
|
|
static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static void socket_init(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(u);
|
2012-01-15 12:04:08 +01:00
|
|
|
assert(u->load_state == UNIT_STUB);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
s->backlog = SOMAXCONN;
|
2013-11-04 17:47:43 +01:00
|
|
|
s->timeout_usec = u->manager->default_timeout_start_usec;
|
2010-04-21 03:27:44 +02:00
|
|
|
s->directory_mode = 0755;
|
2011-05-17 19:37:23 +02:00
|
|
|
s->socket_mode = 0666;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2010-06-19 04:25:28 +02:00
|
|
|
s->max_connections = 64;
|
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
s->priority = -1;
|
|
|
|
s->ip_tos = -1;
|
|
|
|
s->ip_ttl = -1;
|
|
|
|
s->mark = -1;
|
|
|
|
|
2012-01-15 12:04:08 +01:00
|
|
|
s->exec_context.std_output = u->manager->default_std_output;
|
|
|
|
s->exec_context.std_error = u->manager->default_std_error;
|
2014-02-24 23:50:10 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
|
2016-04-26 20:26:15 +02:00
|
|
|
|
2016-05-05 13:39:31 +02:00
|
|
|
s->trigger_limit.interval = USEC_INFINITY;
|
|
|
|
s->trigger_limit.burst = (unsigned) -1;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
2010-01-27 04:31:52 +01:00
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
static void socket_unwatch_control_pid(Socket *s) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->control_pid <= 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
unit_unwatch_pid(UNIT(s), s->control_pid);
|
|
|
|
s->control_pid = 0;
|
|
|
|
}
|
|
|
|
|
2015-09-21 16:30:41 +02:00
|
|
|
static void socket_cleanup_fd_list(SocketPort *p) {
|
2015-10-25 13:14:12 +01:00
|
|
|
assert(p);
|
2015-09-21 16:30:41 +02:00
|
|
|
|
2015-10-25 13:14:12 +01:00
|
|
|
close_many(p->auxiliary_fds, p->n_auxiliary_fds);
|
2015-09-21 16:30:41 +02:00
|
|
|
p->auxiliary_fds = mfree(p->auxiliary_fds);
|
|
|
|
p->n_auxiliary_fds = 0;
|
|
|
|
}
|
|
|
|
|
2013-01-17 02:27:06 +01:00
|
|
|
void socket_free_ports(Socket *s) {
|
2010-01-26 04:18:44 +01:00
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
while ((p = s->ports)) {
|
2013-10-14 06:10:14 +02:00
|
|
|
LIST_REMOVE(port, s->ports, p);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
sd_event_source_unref(p->event_source);
|
|
|
|
|
2015-09-21 16:30:41 +02:00
|
|
|
socket_cleanup_fd_list(p);
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(p->fd);
|
2010-01-26 04:18:44 +01:00
|
|
|
free(p->path);
|
|
|
|
free(p);
|
|
|
|
}
|
2013-01-17 02:27:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void socket_done(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
2016-08-02 19:48:23 +02:00
|
|
|
SocketPeer *p;
|
2013-01-17 02:27:06 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
socket_free_ports(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2016-08-05 02:55:45 +02:00
|
|
|
while ((p = set_steal_first(s->peers_by_address)))
|
2016-08-02 19:48:23 +02:00
|
|
|
p->socket = NULL;
|
|
|
|
|
2016-08-05 02:55:45 +02:00
|
|
|
s->peers_by_address = set_free(s->peers_by_address);
|
2016-08-02 19:48:23 +02:00
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
|
2010-04-10 17:53:17 +02:00
|
|
|
exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
|
2010-01-26 04:18:44 +01:00
|
|
|
s->control_command = NULL;
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_unref(&s->dynamic_creds);
|
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
unit_ref_unset(&s->service);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2015-09-08 18:43:11 +02:00
|
|
|
s->tcp_congestion = mfree(s->tcp_congestion);
|
|
|
|
s->bind_to_device = mfree(s->bind_to_device);
|
2010-01-27 04:31:52 +01:00
|
|
|
|
2015-12-22 11:32:25 +01:00
|
|
|
s->smack = mfree(s->smack);
|
|
|
|
s->smack_ip_in = mfree(s->smack_ip_in);
|
|
|
|
s->smack_ip_out = mfree(s->smack_ip_out);
|
2012-10-29 23:30:05 +01:00
|
|
|
|
2014-06-04 16:19:00 +02:00
|
|
|
strv_free(s->symlinks);
|
|
|
|
|
2015-12-22 11:32:25 +01:00
|
|
|
s->user = mfree(s->user);
|
|
|
|
s->group = mfree(s->group);
|
2014-06-05 09:55:53 +02:00
|
|
|
|
2015-12-22 11:03:53 +01:00
|
|
|
s->fdname = mfree(s->fdname);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
s->timer_event_source = sd_event_source_unref(s->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
|
|
|
static int socket_arm_timer(Socket *s, usec_t usec) {
|
2013-11-19 21:12:59 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->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(s->timer_event_source, usec);
|
2013-11-19 21:12:59 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return sd_event_source_set_enabled(s->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(s)->manager->event,
|
|
|
|
&s->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
|
|
|
socket_dispatch_timer, s);
|
2015-04-29 16:05:32 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
(void) sd_event_source_set_description(s->timer_event_source, "socket-timer");
|
|
|
|
|
|
|
|
return 0;
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2014-07-20 23:58:35 +02:00
|
|
|
int socket_instantiate_service(Socket *s) {
|
|
|
|
_cleanup_free_ char *prefix = NULL, *name = NULL;
|
2010-07-16 19:42:27 +02:00
|
|
|
int r;
|
|
|
|
Unit *u;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
/* This fills in s->service if it isn't filled in yet. For
|
|
|
|
* Accept=yes sockets we create the next connection service
|
|
|
|
* here. For Accept=no this is mostly a NOP since the service
|
|
|
|
* is figured out at load time anyway. */
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (UNIT_DEREF(s->service))
|
2010-07-16 19:42:27 +02:00
|
|
|
return 0;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!s->accept)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = unit_name_to_prefix(UNIT(s)->id, &prefix);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-07-16 19:42:27 +02:00
|
|
|
|
2014-03-14 14:05:56 +01:00
|
|
|
if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
|
2010-07-16 19:42:27 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
|
2010-07-16 19:42:27 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2018-02-13 13:12:43 +01:00
|
|
|
unit_ref_set(&s->service, UNIT(s), u);
|
2012-01-06 23:08:54 +01:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false, UNIT_DEPENDENCY_IMPLICIT);
|
2010-07-16 19:42:27 +02:00
|
|
|
}
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
static bool have_non_accept_socket(Socket *s) {
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (!s->accept)
|
|
|
|
return true;
|
|
|
|
|
2010-04-23 21:56:38 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
|
|
|
|
if (p->type != SOCKET_SOCKET)
|
|
|
|
return true;
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
if (!socket_address_can_accept(&p->address))
|
|
|
|
return true;
|
2010-04-23 21:56:38 +02:00
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int socket_add_mount_dependencies(Socket *s) {
|
2010-05-13 03:07:16 +02:00
|
|
|
SocketPort *p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
const char *path = NULL;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (p->type == SOCKET_SOCKET)
|
|
|
|
path = socket_address_get_path(&p->address);
|
2015-09-21 15:43:47 +02:00
|
|
|
else if (IN_SET(p->type, SOCKET_FIFO, SOCKET_SPECIAL, SOCKET_USB_FUNCTION))
|
2013-09-26 20:14:24 +02:00
|
|
|
path = p->path;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
2013-09-26 20:14:24 +02:00
|
|
|
if (!path)
|
|
|
|
continue;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_require_mounts_for(UNIT(s), path, UNIT_DEPENDENCY_FILE);
|
2012-10-16 19:50:26 +02:00
|
|
|
if (r < 0)
|
2010-05-13 03:07:16 +02:00
|
|
|
return r;
|
2012-10-16 19:50:26 +02:00
|
|
|
}
|
2010-05-13 03:07:16 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
static int socket_add_device_dependencies(Socket *s) {
|
2010-05-13 03:07:16 +02:00
|
|
|
char *t;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2013-01-12 23:05:52 +01:00
|
|
|
if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
|
2010-05-13 03:07:16 +02:00
|
|
|
return 0;
|
|
|
|
|
2015-02-03 02:05:59 +01:00
|
|
|
t = strjoina("/sys/subsystem/net/devices/", s->bind_to_device);
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_node_dependency(UNIT(s), t, false, UNIT_BINDS_TO, UNIT_DEPENDENCY_FILE);
|
2010-05-13 03:07:16 +02:00
|
|
|
}
|
|
|
|
|
2010-07-03 19:48:33 +02:00
|
|
|
static int socket_add_default_dependencies(Socket *s) {
|
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
if (!UNIT(s)->default_dependencies)
|
|
|
|
return 0;
|
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
|
2013-03-25 21:20:08 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-10-29 06:04:03 +02:00
|
|
|
|
2016-02-24 21:24:23 +01:00
|
|
|
if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
|
2013-03-25 21:20:08 +01:00
|
|
|
if (r < 0)
|
2010-07-03 19:48:33 +02:00
|
|
|
return r;
|
2010-10-29 06:04:03 +02:00
|
|
|
}
|
2010-07-03 19:48:33 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
|
2010-07-03 19:48:33 +02:00
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static bool socket_has_exec(Socket *s) {
|
2012-01-03 20:33:28 +01:00
|
|
|
unsigned i;
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
|
|
|
|
if (s->exec_command[i])
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
static int socket_add_extras(Socket *s) {
|
|
|
|
Unit *u = UNIT(s);
|
2010-04-10 17:53:17 +02:00
|
|
|
int r;
|
2010-01-26 07:02:51 +01:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
assert(s);
|
2012-01-06 23:08:54 +01:00
|
|
|
|
2016-05-05 13:39:31 +02:00
|
|
|
/* Pick defaults for the trigger limit, if nothing was explicitly configured. We pick a relatively high limit
|
|
|
|
* in Accept=yes mode, and a lower limit for Accept=no. Reason: in Accept=yes mode we are invoking accept()
|
|
|
|
* ourselves before the trigger limit can hit, thus incoming connections are taken off the socket queue quickly
|
|
|
|
* and reliably. This is different for Accept=no, where the spawned service has to take the incoming traffic
|
|
|
|
* off the queues, which it might not necessarily do. Moreover, while Accept=no services are supposed to
|
|
|
|
* process whatever is queued in one go, and thus should normally never have to be started frequently. This is
|
|
|
|
* different for Accept=yes where each connection is processed by a new service instance, and thus frequent
|
|
|
|
* service starts are typical. */
|
|
|
|
|
|
|
|
if (s->trigger_limit.interval == USEC_INFINITY)
|
|
|
|
s->trigger_limit.interval = 2 * USEC_PER_SEC;
|
|
|
|
|
|
|
|
if (s->trigger_limit.burst == (unsigned) -1) {
|
|
|
|
if (s->accept)
|
|
|
|
s->trigger_limit.burst = 200;
|
|
|
|
else
|
|
|
|
s->trigger_limit.burst = 20;
|
|
|
|
}
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (have_non_accept_socket(s)) {
|
2010-04-06 02:43:58 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (!UNIT_DEREF(s->service)) {
|
|
|
|
Unit *x;
|
2012-01-06 23:08:54 +01:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
r = unit_load_related_unit(u, ".service", &x);
|
2012-01-06 23:08:54 +01:00
|
|
|
if (r < 0)
|
2010-04-15 06:19:54 +02:00
|
|
|
return r;
|
2013-12-02 23:30:19 +01:00
|
|
|
|
2018-02-13 13:12:43 +01:00
|
|
|
unit_ref_set(&s->service, u, x);
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
2010-01-26 07:02:51 +01:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true, UNIT_DEPENDENCY_IMPLICIT);
|
2013-12-02 23:30:19 +01:00
|
|
|
if (r < 0)
|
2010-05-13 03:07:16 +02:00
|
|
|
return r;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = socket_add_mount_dependencies(s);
|
2013-12-02 23:30:19 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-05-13 03:07:16 +02:00
|
|
|
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
r = socket_add_device_dependencies(s);
|
2013-12-02 23:30:19 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-03-19 20:40:05 +01:00
|
|
|
r = unit_patch_contexts(u);
|
2013-12-02 23:30:19 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (socket_has_exec(s)) {
|
|
|
|
r = unit_add_exec_dependencies(u, &s->exec_context);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2013-06-17 21:33:26 +02:00
|
|
|
|
2017-09-22 20:09:21 +02:00
|
|
|
r = unit_set_default_slice(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-11-11 20:42:39 +01:00
|
|
|
r = socket_add_default_dependencies(s);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-12-02 23:30:19 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-04 16:19:00 +02:00
|
|
|
static const char *socket_find_symlink_target(Socket *s) {
|
|
|
|
const char *found = NULL;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
const char *f = NULL;
|
|
|
|
|
|
|
|
switch (p->type) {
|
|
|
|
|
|
|
|
case SOCKET_FIFO:
|
|
|
|
f = p->path;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_SOCKET:
|
2016-12-16 11:20:27 +01:00
|
|
|
f = socket_address_get_path(&p->address);
|
2014-06-04 16:19:00 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (f) {
|
|
|
|
if (found)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
found = f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
static int socket_verify(Socket *s) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (UNIT(s)->load_state != UNIT_LOADED)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!s->ports) {
|
2017-01-11 19:48:16 +01:00
|
|
|
log_unit_error(UNIT(s), "Unit has no Listen setting (ListenStream=, ListenDatagram=, ListenFIFO=, ...). Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->accept && have_non_accept_socket(s)) {
|
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(s), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->accept && s->max_connections <= 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_error(UNIT(s), "MaxConnection= setting too small. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
2012-07-16 12:44:42 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (s->accept && UNIT_DEREF(s->service)) {
|
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(s), "Explicit service configuration for accepting socket units not supported. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->exec_context.pam_name && s->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(s), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
|
|
|
|
2014-06-04 16:19:00 +02:00
|
|
|
if (!strv_isempty(s->symlinks) && !socket_find_symlink_target(s)) {
|
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(s), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
|
2018-06-01 18:06:54 +02:00
|
|
|
return -ENOEXEC;
|
2014-06-04 16:19:00 +02:00
|
|
|
}
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-02 19:48:23 +02:00
|
|
|
static void peer_address_hash_func(const void *p, struct siphash *state) {
|
|
|
|
const SocketPeer *s = p;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->peer.sa.sa_family == AF_INET)
|
|
|
|
siphash24_compress(&s->peer.in.sin_addr, sizeof(s->peer.in.sin_addr), state);
|
2016-12-29 11:21:37 +01:00
|
|
|
else if (s->peer.sa.sa_family == AF_INET6)
|
2016-08-02 19:48:23 +02:00
|
|
|
siphash24_compress(&s->peer.in6.sin6_addr, sizeof(s->peer.in6.sin6_addr), state);
|
2016-12-21 18:02:08 +01:00
|
|
|
else if (s->peer.sa.sa_family == AF_VSOCK)
|
|
|
|
siphash24_compress(&s->peer.vm.svm_cid, sizeof(s->peer.vm.svm_cid), state);
|
2016-12-29 11:21:37 +01:00
|
|
|
else
|
|
|
|
assert_not_reached("Unknown address family.");
|
2016-08-02 19:48:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int peer_address_compare_func(const void *a, const void *b) {
|
|
|
|
const SocketPeer *x = a, *y = b;
|
2018-08-03 01:43:37 +02:00
|
|
|
int r;
|
2016-08-02 19:48:23 +02:00
|
|
|
|
2018-08-03 01:43:37 +02:00
|
|
|
r = CMP(x->peer.sa.sa_family, y->peer.sa.sa_family);
|
|
|
|
if (r != 0)
|
|
|
|
return r;
|
2016-08-02 19:48:23 +02:00
|
|
|
|
|
|
|
switch(x->peer.sa.sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
return memcmp(&x->peer.in.sin_addr, &y->peer.in.sin_addr, sizeof(x->peer.in.sin_addr));
|
|
|
|
case AF_INET6:
|
|
|
|
return memcmp(&x->peer.in6.sin6_addr, &y->peer.in6.sin6_addr, sizeof(x->peer.in6.sin6_addr));
|
2016-12-21 18:02:08 +01:00
|
|
|
case AF_VSOCK:
|
|
|
|
if (x->peer.vm.svm_cid < y->peer.vm.svm_cid)
|
|
|
|
return -1;
|
|
|
|
if (x->peer.vm.svm_cid > y->peer.vm.svm_cid)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
2016-08-02 19:48:23 +02:00
|
|
|
}
|
2016-08-05 03:42:23 +02:00
|
|
|
assert_not_reached("Black sheep in the family!");
|
2016-08-02 19:48:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const struct hash_ops peer_address_hash_ops = {
|
|
|
|
.hash = peer_address_hash_func,
|
|
|
|
.compare = peer_address_compare_func
|
|
|
|
};
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
static int socket_load(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(u->load_state == UNIT_STUB);
|
|
|
|
|
2016-08-05 02:55:45 +02:00
|
|
|
r = set_ensure_allocated(&s->peers_by_address, &peer_address_hash_ops);
|
2016-08-02 19:48:23 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
r = unit_load_fragment_and_dropin(u);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (u->load_state == UNIT_LOADED) {
|
|
|
|
/* This is a new unit? Then let's add in some extras */
|
|
|
|
r = socket_add_extras(s);
|
2012-07-16 12:44:42 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-06 02:43:58 +02:00
|
|
|
}
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
return socket_verify(s);
|
2010-01-26 07:02:51 +01:00
|
|
|
}
|
|
|
|
|
2016-08-05 03:42:23 +02:00
|
|
|
static SocketPeer *socket_peer_new(void) {
|
|
|
|
SocketPeer *p;
|
|
|
|
|
|
|
|
p = new0(SocketPeer, 1);
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
p->n_ref = 1;
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
SocketPeer *socket_peer_ref(SocketPeer *p) {
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(p->n_ref > 0);
|
|
|
|
p->n_ref++;
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
SocketPeer *socket_peer_unref(SocketPeer *p) {
|
|
|
|
if (!p)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(p->n_ref > 0);
|
|
|
|
|
|
|
|
p->n_ref--;
|
|
|
|
|
|
|
|
if (p->n_ref > 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (p->socket)
|
|
|
|
set_remove(p->socket->peers_by_address, p);
|
|
|
|
|
|
|
|
return mfree(p);
|
|
|
|
}
|
|
|
|
|
2016-08-05 05:42:27 +02:00
|
|
|
int socket_acquire_peer(Socket *s, int fd, SocketPeer **p) {
|
2016-08-05 03:42:23 +02:00
|
|
|
_cleanup_(socket_peer_unrefp) SocketPeer *remote = NULL;
|
|
|
|
SocketPeer sa = {}, *i;
|
|
|
|
socklen_t salen = sizeof(sa.peer);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(fd >= 0);
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
r = getpeername(fd, &sa.peer.sa, &salen);
|
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(errno, "getpeername failed: %m");
|
|
|
|
|
2016-12-21 18:02:08 +01:00
|
|
|
if (!IN_SET(sa.peer.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
|
2016-08-05 03:42:23 +02:00
|
|
|
*p = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = set_get(s->peers_by_address, &sa);
|
|
|
|
if (i) {
|
|
|
|
*p = socket_peer_ref(i);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote = socket_peer_new();
|
|
|
|
if (!remote)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
remote->peer = sa.peer;
|
2016-12-29 11:21:37 +01:00
|
|
|
remote->peer_salen = salen;
|
2016-08-05 03:42:23 +02:00
|
|
|
|
|
|
|
r = set_put(s->peers_by_address, remote);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
remote->socket = s;
|
|
|
|
|
2018-04-05 07:26:26 +02:00
|
|
|
*p = TAKE_PTR(remote);
|
2016-08-05 03:42:23 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_const_ static const char* listen_lookup(int family, int type) {
|
2011-04-10 03:27:00 +02:00
|
|
|
|
|
|
|
if (family == AF_NETLINK)
|
|
|
|
return "ListenNetlink";
|
2010-01-23 03:35:54 +01:00
|
|
|
|
|
|
|
if (type == SOCK_STREAM)
|
|
|
|
return "ListenStream";
|
|
|
|
else if (type == SOCK_DGRAM)
|
|
|
|
return "ListenDatagram";
|
|
|
|
else if (type == SOCK_SEQPACKET)
|
|
|
|
return "ListenSequentialPacket";
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
assert_not_reached("Unknown socket type");
|
2010-01-23 03:35:54 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
static void socket_dump(Unit *u, FILE *f, const char *prefix) {
|
2014-08-14 19:36:11 +02:00
|
|
|
char time_string[FORMAT_TIMESPAN_MAX];
|
2010-01-23 01:52:57 +01:00
|
|
|
SocketExecCommand c;
|
2010-01-26 21:39:06 +01:00
|
|
|
Socket *s = SOCKET(u);
|
2010-01-23 03:35:54 +01:00
|
|
|
SocketPort *p;
|
2017-12-23 10:53:36 +01:00
|
|
|
const char *prefix2, *str;
|
2010-01-23 01:52:57 +01:00
|
|
|
|
|
|
|
assert(s);
|
2010-01-27 06:33:27 +01:00
|
|
|
assert(f);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2014-08-21 16:15:49 +02:00
|
|
|
prefix = strempty(prefix);
|
2015-02-03 02:05:59 +01:00
|
|
|
prefix2 = strjoina(prefix, "\t");
|
2010-01-27 02:16:27 +01:00
|
|
|
|
2010-01-23 01:52:57 +01:00
|
|
|
fprintf(f,
|
|
|
|
"%sSocket State: %s\n"
|
2012-02-03 03:27:25 +01:00
|
|
|
"%sResult: %s\n"
|
2010-01-23 03:35:54 +01:00
|
|
|
"%sBindIPv6Only: %s\n"
|
2010-02-12 02:02:14 +01:00
|
|
|
"%sBacklog: %u\n"
|
|
|
|
"%sSocketMode: %04o\n"
|
2010-07-01 00:29:17 +02:00
|
|
|
"%sDirectoryMode: %04o\n"
|
|
|
|
"%sKeepAlive: %s\n"
|
2014-07-28 08:48:29 +02:00
|
|
|
"%sNoDelay: %s\n"
|
2010-08-03 13:33:40 +02:00
|
|
|
"%sFreeBind: %s\n"
|
2011-05-19 13:22:31 +02:00
|
|
|
"%sTransparent: %s\n"
|
2011-05-19 18:10:19 +02:00
|
|
|
"%sBroadcast: %s\n"
|
2012-01-31 23:58:15 +01:00
|
|
|
"%sPassCredentials: %s\n"
|
2012-03-13 00:00:27 +01:00
|
|
|
"%sPassSecurity: %s\n"
|
2014-06-04 13:10:43 +02:00
|
|
|
"%sTCPCongestion: %s\n"
|
2014-07-24 10:40:28 +02:00
|
|
|
"%sRemoveOnStop: %s\n"
|
2015-10-01 14:28:13 +02:00
|
|
|
"%sWritable: %s\n"
|
2017-12-23 10:53:36 +01:00
|
|
|
"%sFileDescriptorName: %s\n"
|
2014-07-24 10:40:28 +02:00
|
|
|
"%sSELinuxContextFromNet: %s\n",
|
2010-04-21 03:27:44 +02:00
|
|
|
prefix, socket_state_to_string(s->state),
|
2012-02-03 03:27:25 +01:00
|
|
|
prefix, socket_result_to_string(s->result),
|
2010-05-21 23:41:25 +02:00
|
|
|
prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
|
2010-02-12 02:02:14 +01:00
|
|
|
prefix, s->backlog,
|
|
|
|
prefix, s->socket_mode,
|
2010-07-01 00:29:17 +02:00
|
|
|
prefix, s->directory_mode,
|
|
|
|
prefix, yes_no(s->keep_alive),
|
2014-07-28 08:48:29 +02:00
|
|
|
prefix, yes_no(s->no_delay),
|
2010-08-03 13:33:40 +02:00
|
|
|
prefix, yes_no(s->free_bind),
|
2011-05-19 13:22:31 +02:00
|
|
|
prefix, yes_no(s->transparent),
|
2011-05-19 18:10:19 +02:00
|
|
|
prefix, yes_no(s->broadcast),
|
2011-11-29 22:15:41 +01:00
|
|
|
prefix, yes_no(s->pass_cred),
|
2012-03-13 00:00:27 +01:00
|
|
|
prefix, yes_no(s->pass_sec),
|
2014-06-04 13:10:43 +02:00
|
|
|
prefix, strna(s->tcp_congestion),
|
2014-07-24 10:40:28 +02:00
|
|
|
prefix, yes_no(s->remove_on_stop),
|
2015-10-01 14:28:13 +02:00
|
|
|
prefix, yes_no(s->writable),
|
2015-10-04 17:36:19 +02:00
|
|
|
prefix, socket_fdname(s),
|
2014-07-24 10:40:28 +02:00
|
|
|
prefix, yes_no(s->selinux_context_from_net));
|
2010-01-23 03:35:54 +01:00
|
|
|
|
2010-04-08 03:48:27 +02:00
|
|
|
if (s->control_pid > 0)
|
|
|
|
fprintf(f,
|
2014-04-25 13:45:15 +02:00
|
|
|
"%sControl PID: "PID_FMT"\n",
|
|
|
|
prefix, s->control_pid);
|
2010-04-08 03:48:27 +02:00
|
|
|
|
2010-01-27 04:31:52 +01:00
|
|
|
if (s->bind_to_device)
|
|
|
|
fprintf(f,
|
|
|
|
"%sBindToDevice: %s\n",
|
|
|
|
prefix, s->bind_to_device);
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
if (s->accept)
|
|
|
|
fprintf(f,
|
2010-06-19 04:25:28 +02:00
|
|
|
"%sAccepted: %u\n"
|
|
|
|
"%sNConnections: %u\n"
|
2017-12-23 10:53:36 +01:00
|
|
|
"%sMaxConnections: %u\n"
|
|
|
|
"%sMaxConnectionsPerSource: %u\n",
|
2010-06-19 04:25:28 +02:00
|
|
|
prefix, s->n_accepted,
|
|
|
|
prefix, s->n_connections,
|
2017-12-23 10:53:36 +01:00
|
|
|
prefix, s->max_connections,
|
|
|
|
prefix, s->max_connections_per_source);
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
if (s->priority >= 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sPriority: %i\n",
|
|
|
|
prefix, s->priority);
|
|
|
|
|
|
|
|
if (s->receive_buffer > 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sReceiveBuffer: %zu\n",
|
|
|
|
prefix, s->receive_buffer);
|
|
|
|
|
|
|
|
if (s->send_buffer > 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sSendBuffer: %zu\n",
|
|
|
|
prefix, s->send_buffer);
|
|
|
|
|
|
|
|
if (s->ip_tos >= 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sIPTOS: %i\n",
|
|
|
|
prefix, s->ip_tos);
|
|
|
|
|
|
|
|
if (s->ip_ttl >= 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sIPTTL: %i\n",
|
|
|
|
prefix, s->ip_ttl);
|
|
|
|
|
|
|
|
if (s->pipe_size > 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sPipeSize: %zu\n",
|
|
|
|
prefix, s->pipe_size);
|
|
|
|
|
|
|
|
if (s->mark >= 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sMark: %i\n",
|
|
|
|
prefix, s->mark);
|
|
|
|
|
2011-05-17 19:37:03 +02:00
|
|
|
if (s->mq_maxmsg > 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sMessageQueueMaxMessages: %li\n",
|
|
|
|
prefix, s->mq_maxmsg);
|
|
|
|
|
|
|
|
if (s->mq_msgsize > 0)
|
|
|
|
fprintf(f,
|
|
|
|
"%sMessageQueueMessageSize: %li\n",
|
|
|
|
prefix, s->mq_msgsize);
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (s->reuse_port)
|
2013-07-08 20:28:14 +02:00
|
|
|
fprintf(f,
|
|
|
|
"%sReusePort: %s\n",
|
2013-11-19 21:12:59 +01:00
|
|
|
prefix, yes_no(s->reuse_port));
|
2013-07-08 20:28:14 +02:00
|
|
|
|
2012-10-29 23:30:05 +01:00
|
|
|
if (s->smack)
|
|
|
|
fprintf(f,
|
|
|
|
"%sSmackLabel: %s\n",
|
|
|
|
prefix, s->smack);
|
|
|
|
|
|
|
|
if (s->smack_ip_in)
|
|
|
|
fprintf(f,
|
|
|
|
"%sSmackLabelIPIn: %s\n",
|
|
|
|
prefix, s->smack_ip_in);
|
|
|
|
|
|
|
|
if (s->smack_ip_out)
|
|
|
|
fprintf(f,
|
|
|
|
"%sSmackLabelIPOut: %s\n",
|
|
|
|
prefix, s->smack_ip_out);
|
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (!isempty(s->user) || !isempty(s->group))
|
|
|
|
fprintf(f,
|
2016-05-05 13:45:18 +02:00
|
|
|
"%sSocketUser: %s\n"
|
|
|
|
"%sSocketGroup: %s\n",
|
2014-06-05 09:55:53 +02:00
|
|
|
prefix, strna(s->user),
|
|
|
|
prefix, strna(s->group));
|
|
|
|
|
2014-08-19 21:57:37 +02:00
|
|
|
if (s->keep_alive_time > 0)
|
2014-08-14 19:36:11 +02:00
|
|
|
fprintf(f,
|
2014-08-19 21:57:37 +02:00
|
|
|
"%sKeepAliveTimeSec: %s\n",
|
|
|
|
prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_time, USEC_PER_SEC));
|
2014-08-14 19:36:11 +02:00
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->keep_alive_interval > 0)
|
2014-08-14 19:36:11 +02:00
|
|
|
fprintf(f,
|
2014-08-19 21:57:37 +02:00
|
|
|
"%sKeepAliveIntervalSec: %s\n",
|
|
|
|
prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_interval, USEC_PER_SEC));
|
2014-08-14 19:36:11 +02:00
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->keep_alive_cnt > 0)
|
2014-08-14 19:36:11 +02:00
|
|
|
fprintf(f,
|
|
|
|
"%sKeepAliveProbes: %u\n",
|
|
|
|
prefix, s->keep_alive_cnt);
|
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->defer_accept > 0)
|
2014-08-14 19:36:12 +02:00
|
|
|
fprintf(f,
|
2014-08-19 21:57:37 +02:00
|
|
|
"%sDeferAcceptSec: %s\n",
|
|
|
|
prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->defer_accept, USEC_PER_SEC));
|
2014-08-14 19:36:12 +02:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
switch (p->type) {
|
|
|
|
case SOCKET_SOCKET: {
|
|
|
|
_cleanup_free_ char *k = NULL;
|
2010-01-23 03:35:54 +01:00
|
|
|
const char *t;
|
|
|
|
int r;
|
|
|
|
|
2015-09-30 22:16:17 +02:00
|
|
|
r = socket_address_print(&p->address, &k);
|
|
|
|
if (r < 0)
|
2010-01-23 03:35:54 +01:00
|
|
|
t = strerror(-r);
|
|
|
|
else
|
|
|
|
t = k;
|
|
|
|
|
2011-04-10 03:27:00 +02:00
|
|
|
fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
|
2018-05-29 06:32:05 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SOCKET_SPECIAL:
|
2011-04-20 05:02:23 +02:00
|
|
|
fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
|
2018-05-29 06:32:05 +02:00
|
|
|
break;
|
|
|
|
case SOCKET_USB_FUNCTION:
|
2015-09-21 15:43:47 +02:00
|
|
|
fprintf(f, "%sListenUSBFunction: %s\n", prefix, p->path);
|
2018-05-29 06:32:05 +02:00
|
|
|
break;
|
|
|
|
case SOCKET_MQUEUE:
|
2011-05-17 19:37:03 +02:00
|
|
|
fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
|
2018-05-29 06:32:05 +02:00
|
|
|
break;
|
|
|
|
default:
|
2010-01-23 03:35:54 +01:00
|
|
|
fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
|
2018-05-29 06:32:05 +02:00
|
|
|
}
|
2010-01-23 03:35:54 +01:00
|
|
|
}
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2016-05-06 23:03:16 +02:00
|
|
|
fprintf(f,
|
|
|
|
"%sTriggerLimitIntervalSec: %s\n"
|
|
|
|
"%sTriggerLimitBurst: %u\n",
|
|
|
|
prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->trigger_limit.interval, USEC_PER_SEC),
|
|
|
|
prefix, s->trigger_limit.burst);
|
|
|
|
|
2017-12-23 10:53:36 +01:00
|
|
|
str = socket_protocol_to_name(s->socket_protocol);
|
|
|
|
if (str)
|
|
|
|
fprintf(f, "%sSocketProtocol: %s\n", prefix, str);
|
|
|
|
|
|
|
|
if (!strv_isempty(s->symlinks)) {
|
|
|
|
char **q;
|
|
|
|
|
|
|
|
fprintf(f, "%sSymlinks:", prefix);
|
|
|
|
STRV_FOREACH(q, s->symlinks)
|
|
|
|
fprintf(f, " %s", *q);
|
|
|
|
|
|
|
|
fprintf(f, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"%sTimeoutSec: %s\n",
|
|
|
|
prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->timeout_usec, USEC_PER_SEC));
|
|
|
|
|
2010-01-23 01:52:57 +01:00
|
|
|
exec_context_dump(&s->exec_context, f, prefix);
|
2012-07-19 23:47:10 +02:00
|
|
|
kill_context_dump(&s->kill_context, f, prefix);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
|
2010-01-27 02:16:27 +01:00
|
|
|
if (!s->exec_command[c])
|
|
|
|
continue;
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-04-23 20:25:55 +02:00
|
|
|
fprintf(f, "%s-> %s:\n",
|
2010-04-21 03:27:44 +02:00
|
|
|
prefix, socket_exec_command_to_string(c));
|
2010-01-27 02:16:27 +01:00
|
|
|
|
|
|
|
exec_command_dump_list(s->exec_command[c], f, prefix2);
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
2017-09-05 19:20:29 +02:00
|
|
|
|
|
|
|
cgroup_context_dump(&s->cgroup_context, f, prefix);
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
static int instance_from_socket(int fd, unsigned nr, char **instance) {
|
|
|
|
socklen_t l;
|
|
|
|
char *r;
|
2014-03-12 20:09:25 +01:00
|
|
|
union sockaddr_union local, remote;
|
2010-04-15 06:19:54 +02:00
|
|
|
|
|
|
|
assert(fd >= 0);
|
|
|
|
assert(instance);
|
|
|
|
|
|
|
|
l = sizeof(local);
|
|
|
|
if (getsockname(fd, &local.sa, &l) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
l = sizeof(remote);
|
|
|
|
if (getpeername(fd, &remote.sa, &l) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
switch (local.sa.sa_family) {
|
|
|
|
|
|
|
|
case AF_INET: {
|
|
|
|
uint32_t
|
2016-06-15 01:26:01 +02:00
|
|
|
a = be32toh(local.in.sin_addr.s_addr),
|
|
|
|
b = be32toh(remote.in.sin_addr.s_addr);
|
2010-04-15 06:19:54 +02:00
|
|
|
|
|
|
|
if (asprintf(&r,
|
2012-03-14 03:07:26 +01:00
|
|
|
"%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
|
|
|
|
nr,
|
2010-04-15 06:19:54 +02:00
|
|
|
a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(local.in.sin_port),
|
2010-04-15 06:19:54 +02:00
|
|
|
b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(remote.in.sin_port)) < 0)
|
2010-04-15 06:19:54 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case AF_INET6: {
|
2012-09-15 18:58:48 +02:00
|
|
|
static const unsigned char ipv4_prefix[] = {
|
2010-05-20 20:46:06 +02:00
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
|
|
|
|
};
|
|
|
|
|
|
|
|
if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
|
|
|
|
memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
|
|
|
|
const uint8_t
|
|
|
|
*a = local.in6.sin6_addr.s6_addr+12,
|
|
|
|
*b = remote.in6.sin6_addr.s6_addr+12;
|
|
|
|
|
|
|
|
if (asprintf(&r,
|
2012-03-14 03:07:26 +01:00
|
|
|
"%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
|
|
|
|
nr,
|
2010-05-20 20:46:06 +02:00
|
|
|
a[0], a[1], a[2], a[3],
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(local.in6.sin6_port),
|
2010-05-20 20:46:06 +02:00
|
|
|
b[0], b[1], b[2], b[3],
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(remote.in6.sin6_port)) < 0)
|
2010-05-20 20:46:06 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
} else {
|
|
|
|
char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
|
|
|
|
|
|
|
|
if (asprintf(&r,
|
2012-03-14 03:07:26 +01:00
|
|
|
"%u-%s:%u-%s:%u",
|
|
|
|
nr,
|
2010-05-20 20:46:06 +02:00
|
|
|
inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(local.in6.sin6_port),
|
2010-05-20 20:46:06 +02:00
|
|
|
inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
|
2016-06-15 01:26:01 +02:00
|
|
|
be16toh(remote.in6.sin6_port)) < 0)
|
2010-05-20 20:46:06 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case AF_UNIX: {
|
|
|
|
struct ucred ucred;
|
2013-12-24 15:53:04 +01:00
|
|
|
int k;
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2013-12-24 15:53:04 +01:00
|
|
|
k = getpeercred(fd, &ucred);
|
2014-04-20 03:58:03 +02:00
|
|
|
if (k >= 0) {
|
|
|
|
if (asprintf(&r,
|
|
|
|
"%u-"PID_FMT"-"UID_FMT,
|
|
|
|
nr, ucred.pid, ucred.uid) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
} else if (k == -ENODATA) {
|
|
|
|
/* This handles the case where somebody is
|
|
|
|
* connecting from another pid/uid namespace
|
|
|
|
* (e.g. from outside of our container). */
|
|
|
|
if (asprintf(&r,
|
|
|
|
"%u-unknown",
|
|
|
|
nr) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
} else
|
2013-12-24 15:53:04 +01:00
|
|
|
return k;
|
2014-04-19 13:53:11 +02:00
|
|
|
|
|
|
|
break;
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
|
|
|
|
2016-12-21 18:02:08 +01:00
|
|
|
case AF_VSOCK:
|
|
|
|
if (asprintf(&r,
|
|
|
|
"%u-%u:%u-%u:%u",
|
|
|
|
nr,
|
|
|
|
local.vm.svm_cid, local.vm.svm_port,
|
|
|
|
remote.vm.svm_cid, remote.vm.svm_port) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
default:
|
|
|
|
assert_not_reached("Unhandled socket type.");
|
|
|
|
}
|
|
|
|
|
|
|
|
*instance = r;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
static void socket_close_fds(Socket *s) {
|
2010-01-23 22:56:47 +01:00
|
|
|
SocketPort *p;
|
2014-06-04 16:19:00 +02:00
|
|
|
char **i;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
2016-04-28 21:47:20 +02:00
|
|
|
bool was_open;
|
2013-11-19 21:12:59 +01:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
was_open = p->fd >= 0;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
p->event_source = sd_event_source_unref(p->event_source);
|
2014-03-18 19:22:43 +01:00
|
|
|
p->fd = safe_close(p->fd);
|
2015-09-21 16:30:41 +02:00
|
|
|
socket_cleanup_fd_list(p);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
/* One little note: we should normally not delete any sockets in the file system here! After all some
|
|
|
|
* other process we spawned might still have a reference of this fd and wants to continue to use
|
|
|
|
* it. Therefore we normally delete sockets in the file system before we create a new one, not after we
|
|
|
|
* stopped using one! That all said, if the user explicitly requested this, we'll delete them here
|
|
|
|
* anyway, but only then. */
|
2014-06-04 13:10:43 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
if (!was_open || !s->remove_on_stop)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (p->type) {
|
2014-06-04 13:10:43 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
case SOCKET_FIFO:
|
|
|
|
(void) unlink(p->path);
|
|
|
|
break;
|
2014-06-04 13:10:43 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
case SOCKET_MQUEUE:
|
|
|
|
(void) mq_unlink(p->path);
|
|
|
|
break;
|
2014-06-04 13:10:43 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
case SOCKET_SOCKET:
|
|
|
|
(void) socket_address_unlink(&p->address);
|
|
|
|
break;
|
2014-06-04 13:10:43 +02:00
|
|
|
|
2016-04-28 21:47:20 +02:00
|
|
|
default:
|
|
|
|
break;
|
2014-06-04 13:10:43 +02:00
|
|
|
}
|
2010-01-23 22:56:47 +01:00
|
|
|
}
|
2014-06-04 16:19:00 +02:00
|
|
|
|
|
|
|
if (s->remove_on_stop)
|
|
|
|
STRV_FOREACH(i, s->symlinks)
|
2016-04-28 21:47:20 +02:00
|
|
|
(void) unlink(*i);
|
2010-01-23 22:56:47 +01:00
|
|
|
}
|
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
static void socket_apply_socket_options(Socket *s, int fd) {
|
2014-10-23 18:06:51 +02:00
|
|
|
int r;
|
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
assert(s);
|
|
|
|
assert(fd >= 0);
|
|
|
|
|
|
|
|
if (s->keep_alive) {
|
2018-05-29 06:32:05 +02:00
|
|
|
int one = 1;
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)) < 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_warning_errno(UNIT(s), errno, "SO_KEEPALIVE failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
}
|
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->keep_alive_time > 0) {
|
2014-08-14 19:36:11 +02:00
|
|
|
int value = s->keep_alive_time / USEC_PER_SEC;
|
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &value, sizeof(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_warning_errno(UNIT(s), errno, "TCP_KEEPIDLE failed: %m");
|
2014-08-14 19:36:11 +02:00
|
|
|
}
|
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->keep_alive_interval > 0) {
|
2015-06-08 20:53:16 +02:00
|
|
|
int value = s->keep_alive_interval / USEC_PER_SEC;
|
2014-08-14 19:36:11 +02:00
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &value, sizeof(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_warning_errno(UNIT(s), errno, "TCP_KEEPINTVL failed: %m");
|
2014-08-14 19:36:11 +02:00
|
|
|
}
|
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->keep_alive_cnt > 0) {
|
2014-08-14 19:36:11 +02:00
|
|
|
int value = s->keep_alive_cnt;
|
2015-08-31 11:45:09 +02:00
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_KEEPCNT, &value, sizeof(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_warning_errno(UNIT(s), errno, "TCP_KEEPCNT failed: %m");
|
2014-08-14 19:36:11 +02:00
|
|
|
}
|
|
|
|
|
2018-05-29 06:32:05 +02:00
|
|
|
if (s->defer_accept > 0) {
|
2014-08-14 19:36:12 +02:00
|
|
|
int value = s->defer_accept / USEC_PER_SEC;
|
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_DEFER_ACCEPT, &value, sizeof(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_warning_errno(UNIT(s), errno, "TCP_DEFER_ACCEPT failed: %m");
|
2014-08-14 19:36:12 +02:00
|
|
|
}
|
|
|
|
|
2014-07-28 08:48:29 +02:00
|
|
|
if (s->no_delay) {
|
2018-05-29 06:32:05 +02:00
|
|
|
int one = 1;
|
2015-12-31 07:35:57 +01:00
|
|
|
|
|
|
|
if (s->socket_protocol == IPPROTO_SCTP) {
|
2018-05-29 06:32:05 +02:00
|
|
|
if (setsockopt(fd, SOL_SCTP, SCTP_NODELAY, &one, sizeof(one)) < 0)
|
2015-12-31 07:35:57 +01:00
|
|
|
log_unit_warning_errno(UNIT(s), errno, "SCTP_NODELAY failed: %m");
|
|
|
|
} else {
|
2018-05-29 06:32:05 +02:00
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
|
2015-12-31 07:35:57 +01:00
|
|
|
log_unit_warning_errno(UNIT(s), errno, "TCP_NODELAY failed: %m");
|
|
|
|
}
|
2014-07-28 08:48:29 +02:00
|
|
|
}
|
|
|
|
|
2011-05-19 18:10:19 +02:00
|
|
|
if (s->broadcast) {
|
|
|
|
int one = 1;
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 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_warning_errno(UNIT(s), errno, "SO_BROADCAST failed: %m");
|
2011-05-19 18:10:19 +02:00
|
|
|
}
|
|
|
|
|
2011-11-29 22:15:41 +01:00
|
|
|
if (s->pass_cred) {
|
|
|
|
int one = 1;
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 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_warning_errno(UNIT(s), errno, "SO_PASSCRED failed: %m");
|
2011-11-29 22:15:41 +01:00
|
|
|
}
|
|
|
|
|
2012-03-13 00:00:27 +01:00
|
|
|
if (s->pass_sec) {
|
|
|
|
int one = 1;
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 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_warning_errno(UNIT(s), errno, "SO_PASSSEC failed: %m");
|
2012-03-13 00:00:27 +01:00
|
|
|
}
|
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
if (s->priority >= 0)
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 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_warning_errno(UNIT(s), errno, "SO_PRIORITY failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
|
|
|
|
if (s->receive_buffer > 0) {
|
|
|
|
int value = (int) s->receive_buffer;
|
2012-01-27 18:58:02 +01:00
|
|
|
|
|
|
|
/* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
|
2011-05-20 18:41:44 +02:00
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
|
2012-01-27 18:58:02 +01:00
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(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_warning_errno(UNIT(s), errno, "SO_RCVBUF failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->send_buffer > 0) {
|
|
|
|
int value = (int) s->send_buffer;
|
2011-05-20 18:41:44 +02:00
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
|
2012-01-27 18:58:02 +01:00
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(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_warning_errno(UNIT(s), errno, "SO_SNDBUF failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->mark >= 0)
|
|
|
|
if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 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_warning_errno(UNIT(s), errno, "SO_MARK failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
|
|
|
|
if (s->ip_tos >= 0)
|
|
|
|
if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 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_warning_errno(UNIT(s), errno, "IP_TOS failed: %m");
|
2010-07-01 00:29:17 +02:00
|
|
|
|
2010-07-01 15:27:30 +02:00
|
|
|
if (s->ip_ttl >= 0) {
|
2014-10-23 18:06:51 +02:00
|
|
|
int x;
|
2010-07-01 15:27:30 +02:00
|
|
|
|
|
|
|
r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
|
2010-09-20 21:33:14 +02:00
|
|
|
|
|
|
|
if (socket_ipv6_is_supported())
|
|
|
|
x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
|
|
|
|
else {
|
|
|
|
x = -1;
|
|
|
|
errno = EAFNOSUPPORT;
|
|
|
|
}
|
2010-07-01 15:27:30 +02:00
|
|
|
|
|
|
|
if (r < 0 && x < 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_warning_errno(UNIT(s), errno, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
|
2010-07-01 15:27:30 +02:00
|
|
|
}
|
2010-08-03 13:33:40 +02:00
|
|
|
|
|
|
|
if (s->tcp_congestion)
|
|
|
|
if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 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_warning_errno(UNIT(s), errno, "TCP_CONGESTION failed: %m");
|
2012-10-29 23:30:05 +01:00
|
|
|
|
2014-10-23 18:06:51 +02:00
|
|
|
if (s->smack_ip_in) {
|
2015-07-27 19:43:55 +02:00
|
|
|
r = mac_smack_apply_fd(fd, SMACK_ATTR_IPIN, s->smack_ip_in);
|
2014-10-23 18:06:51 +02:00
|
|
|
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
|
|
|
log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_in_fd: %m");
|
2014-10-23 18:06:51 +02:00
|
|
|
}
|
2013-10-11 09:47:31 +02:00
|
|
|
|
2014-10-23 18:06:51 +02:00
|
|
|
if (s->smack_ip_out) {
|
2015-07-27 19:43:55 +02:00
|
|
|
r = mac_smack_apply_fd(fd, SMACK_ATTR_IPOUT, s->smack_ip_out);
|
2014-10-23 18:06:51 +02:00
|
|
|
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
|
|
|
log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_out_fd: %m");
|
2014-10-23 18:06:51 +02:00
|
|
|
}
|
2010-07-01 00:29:17 +02:00
|
|
|
}
|
|
|
|
|
2010-07-16 19:42:27 +02:00
|
|
|
static void socket_apply_fifo_options(Socket *s, int fd) {
|
2014-10-23 18:06:51 +02:00
|
|
|
int r;
|
|
|
|
|
2010-07-01 00:29:17 +02:00
|
|
|
assert(s);
|
|
|
|
assert(fd >= 0);
|
|
|
|
|
|
|
|
if (s->pipe_size > 0)
|
|
|
|
if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
|
2015-09-23 19:51:45 +02:00
|
|
|
log_unit_warning_errno(UNIT(s), errno, "Setting pipe size failed, ignoring: %m");
|
2012-10-29 23:30:05 +01:00
|
|
|
|
2014-10-23 18:06:51 +02:00
|
|
|
if (s->smack) {
|
2015-07-27 19:43:55 +02:00
|
|
|
r = mac_smack_apply_fd(fd, SMACK_ATTR_ACCESS, s->smack);
|
2014-10-23 18:06:51 +02:00
|
|
|
if (r < 0)
|
2015-09-23 19:51:45 +02:00
|
|
|
log_unit_error_errno(UNIT(s), r, "SMACK relabelling failed, ignoring: %m");
|
2014-10-23 18:06:51 +02:00
|
|
|
}
|
2010-07-01 00:29:17 +02:00
|
|
|
}
|
|
|
|
|
2010-07-16 19:42:27 +02:00
|
|
|
static int fifo_address_create(
|
|
|
|
const char *path,
|
|
|
|
mode_t directory_mode,
|
2015-09-23 19:52:23 +02:00
|
|
|
mode_t socket_mode) {
|
2010-07-16 19:42:27 +02:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
_cleanup_close_ int fd = -1;
|
2010-07-16 19:42:27 +02:00
|
|
|
mode_t old_mask;
|
2015-09-23 19:52:23 +02:00
|
|
|
struct stat st;
|
|
|
|
int r;
|
2010-07-16 19:42:27 +02:00
|
|
|
|
|
|
|
assert(path);
|
|
|
|
|
2017-09-26 18:27:56 +02:00
|
|
|
(void) mkdir_parents_label(path, directory_mode);
|
2010-07-16 19:42:27 +02:00
|
|
|
|
2014-10-23 19:41:27 +02:00
|
|
|
r = mac_selinux_create_file_prepare(path, S_IFIFO);
|
2012-04-17 16:05:03 +02:00
|
|
|
if (r < 0)
|
2015-09-23 19:52:23 +02:00
|
|
|
return r;
|
2010-07-16 19:42:27 +02:00
|
|
|
|
|
|
|
/* Enforce the right access mode for the fifo */
|
2018-05-29 06:32:05 +02:00
|
|
|
old_mask = umask(~socket_mode);
|
2010-07-16 19:42:27 +02:00
|
|
|
|
|
|
|
/* Include the original umask in our mask */
|
2015-09-23 19:52:23 +02:00
|
|
|
(void) umask(~socket_mode | old_mask);
|
2010-07-16 19:42:27 +02:00
|
|
|
|
|
|
|
r = mkfifo(path, socket_mode);
|
2015-09-23 19:52:23 +02:00
|
|
|
(void) umask(old_mask);
|
2010-07-16 19:42:27 +02:00
|
|
|
|
2011-04-16 03:42:37 +02:00
|
|
|
if (r < 0 && errno != EEXIST) {
|
2010-07-16 19:42:27 +02:00
|
|
|
r = -errno;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
fd = open(path, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW);
|
2015-09-08 19:14:10 +02:00
|
|
|
if (fd < 0) {
|
2010-07-16 19:42:27 +02:00
|
|
|
r = -errno;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_clear();
|
2010-07-22 23:01:25 +02:00
|
|
|
|
2010-07-16 19:42:27 +02:00
|
|
|
if (fstat(fd, &st) < 0) {
|
|
|
|
r = -errno;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISFIFO(st.st_mode) ||
|
2010-07-20 20:40:49 +02:00
|
|
|
(st.st_mode & 0777) != (socket_mode & ~old_mask) ||
|
2012-11-06 15:54:17 +01:00
|
|
|
st.st_uid != getuid() ||
|
|
|
|
st.st_gid != getgid()) {
|
2010-07-16 19:42:27 +02:00
|
|
|
r = -EEXIST;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2018-03-22 17:04:29 +01:00
|
|
|
return TAKE_FD(fd);
|
2010-07-16 19:42:27 +02:00
|
|
|
|
|
|
|
fail:
|
2014-10-23 19:41:27 +02:00
|
|
|
mac_selinux_create_file_clear();
|
2010-07-16 19:42:27 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2015-10-01 14:28:13 +02:00
|
|
|
static int special_address_create(const char *path, bool writable) {
|
2015-09-23 19:52:23 +02:00
|
|
|
_cleanup_close_ int fd = -1;
|
2011-04-20 05:02:23 +02:00
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
assert(path);
|
|
|
|
|
2015-10-01 14:28:13 +02:00
|
|
|
fd = open(path, (writable ? O_RDWR : O_RDONLY)|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
|
2015-09-23 19:52:23 +02:00
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
2011-04-20 05:02:23 +02:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
if (fstat(fd, &st) < 0)
|
|
|
|
return -errno;
|
2011-04-20 05:02:23 +02:00
|
|
|
|
|
|
|
/* Check whether this is a /proc, /sys or /dev file or char device */
|
2015-09-23 19:52:23 +02:00
|
|
|
if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode))
|
|
|
|
return -EEXIST;
|
2011-04-20 05:02:23 +02:00
|
|
|
|
2018-03-22 17:04:29 +01:00
|
|
|
return TAKE_FD(fd);
|
2011-04-20 05:02:23 +02:00
|
|
|
}
|
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
static int usbffs_address_create(const char *path) {
|
2015-09-21 15:43:47 +02:00
|
|
|
_cleanup_close_ int fd = -1;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
assert(path);
|
|
|
|
|
|
|
|
fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
if (fstat(fd, &st) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
2017-02-24 18:14:02 +01:00
|
|
|
/* Check whether this is a regular file (ffs endpoint) */
|
2015-09-21 15:43:47 +02:00
|
|
|
if (!S_ISREG(st.st_mode))
|
|
|
|
return -EEXIST;
|
|
|
|
|
2018-03-22 17:04:29 +01:00
|
|
|
return TAKE_FD(fd);
|
2015-09-21 15:43:47 +02:00
|
|
|
}
|
|
|
|
|
2011-05-17 19:37:03 +02:00
|
|
|
static int mq_address_create(
|
|
|
|
const char *path,
|
|
|
|
mode_t mq_mode,
|
|
|
|
long maxmsg,
|
2015-09-23 19:52:23 +02:00
|
|
|
long msgsize) {
|
2011-05-17 19:37:03 +02:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
_cleanup_close_ int fd = -1;
|
2011-05-17 19:37:03 +02:00
|
|
|
struct stat st;
|
|
|
|
mode_t old_mask;
|
|
|
|
struct mq_attr _attr, *attr = NULL;
|
|
|
|
|
|
|
|
assert(path);
|
|
|
|
|
|
|
|
if (maxmsg > 0 && msgsize > 0) {
|
2015-09-23 19:52:23 +02:00
|
|
|
_attr = (struct mq_attr) {
|
|
|
|
.mq_flags = O_NONBLOCK,
|
|
|
|
.mq_maxmsg = maxmsg,
|
|
|
|
.mq_msgsize = msgsize,
|
|
|
|
};
|
2011-05-17 19:37:03 +02:00
|
|
|
attr = &_attr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enforce the right access mode for the mq */
|
2018-05-29 06:32:05 +02:00
|
|
|
old_mask = umask(~mq_mode);
|
2011-05-17 19:37:03 +02:00
|
|
|
|
|
|
|
/* Include the original umask in our mask */
|
2015-09-23 19:52:23 +02:00
|
|
|
(void) umask(~mq_mode | old_mask);
|
2011-05-17 19:37:03 +02:00
|
|
|
fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
|
2015-09-23 19:52:23 +02:00
|
|
|
(void) umask(old_mask);
|
2011-05-17 19:37:03 +02:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
2011-05-17 19:37:03 +02:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
if (fstat(fd, &st) < 0)
|
|
|
|
return -errno;
|
2011-05-17 19:37:03 +02:00
|
|
|
|
|
|
|
if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
|
|
|
|
st.st_uid != getuid() ||
|
2015-09-23 19:52:23 +02:00
|
|
|
st.st_gid != getgid())
|
|
|
|
return -EEXIST;
|
2011-05-17 19:37:03 +02:00
|
|
|
|
2018-03-22 17:04:29 +01:00
|
|
|
return TAKE_FD(fd);
|
2011-05-17 19:37:03 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 16:19:00 +02:00
|
|
|
static int socket_symlink(Socket *s) {
|
|
|
|
const char *p;
|
|
|
|
char **i;
|
2017-09-26 18:27:09 +02:00
|
|
|
int r;
|
2014-06-04 16:19:00 +02:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
p = socket_find_symlink_target(s);
|
|
|
|
if (!p)
|
|
|
|
return 0;
|
|
|
|
|
2017-09-26 18:27:09 +02:00
|
|
|
STRV_FOREACH(i, s->symlinks) {
|
2017-09-26 18:27:56 +02:00
|
|
|
(void) mkdir_parents_label(*i, s->directory_mode);
|
|
|
|
|
2017-09-26 18:27:09 +02:00
|
|
|
r = symlink_idempotent(p, *i);
|
2017-09-27 17:48:28 +02:00
|
|
|
|
|
|
|
if (r == -EEXIST && s->remove_on_stop) {
|
|
|
|
/* If there's already something where we want to create the symlink, and the destructive
|
|
|
|
* RemoveOnStop= mode is set, then we might as well try to remove what already exists and try
|
|
|
|
* again. */
|
|
|
|
|
|
|
|
if (unlink(*i) >= 0)
|
|
|
|
r = symlink_idempotent(p, *i);
|
|
|
|
}
|
|
|
|
|
2017-09-26 18:27:09 +02:00
|
|
|
if (r < 0)
|
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to create symlink %s → %s, ignoring: %m", p, *i);
|
|
|
|
}
|
2014-06-04 16:19:00 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
static int usbffs_write_descs(int fd, Service *s) {
|
2015-09-04 12:23:51 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!s->usb_function_descriptors || !s->usb_function_strings)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-02-13 19:00:22 +01:00
|
|
|
r = copy_file_fd(s->usb_function_descriptors, fd, 0);
|
2015-09-04 12:23:51 +02:00
|
|
|
if (r < 0)
|
2015-09-23 19:52:23 +02:00
|
|
|
return r;
|
2015-09-04 12:23:51 +02:00
|
|
|
|
2017-02-13 19:00:22 +01:00
|
|
|
return copy_file_fd(s->usb_function_strings, fd, 0);
|
2015-09-04 12:23:51 +02:00
|
|
|
}
|
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
static int usbffs_select_ep(const struct dirent *d) {
|
2015-09-21 15:43:47 +02:00
|
|
|
return d->d_name[0] != '.' && !streq(d->d_name, "ep0");
|
|
|
|
}
|
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
static int usbffs_dispatch_eps(SocketPort *p) {
|
2015-09-21 15:43:47 +02:00
|
|
|
_cleanup_free_ struct dirent **ent = NULL;
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
size_t n, k, i;
|
|
|
|
int r;
|
2015-09-21 15:43:47 +02:00
|
|
|
|
2016-09-26 18:45:47 +02:00
|
|
|
r = scandir(p->path, &ent, usbffs_select_ep, alphasort);
|
2015-09-21 15:43:47 +02:00
|
|
|
if (r < 0)
|
|
|
|
return -errno;
|
|
|
|
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
n = (size_t) r;
|
2015-09-21 15:43:47 +02:00
|
|
|
p->auxiliary_fds = new(int, n);
|
|
|
|
if (!p->auxiliary_fds)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
p->n_auxiliary_fds = n;
|
|
|
|
|
|
|
|
k = 0;
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
|
|
_cleanup_free_ char *ep = NULL;
|
|
|
|
|
2016-09-26 18:45:47 +02:00
|
|
|
ep = path_make_absolute(ent[i]->d_name, p->path);
|
2015-09-21 15:43:47 +02:00
|
|
|
if (!ep)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2018-05-31 16:39:31 +02:00
|
|
|
path_simplify(ep, false);
|
2015-09-21 15:43:47 +02:00
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
r = usbffs_address_create(ep);
|
2015-09-21 15:43:47 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
p->auxiliary_fds[k++] = r;
|
2015-09-21 15:43:47 +02:00
|
|
|
free(ent[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
fail:
|
2015-09-23 19:52:23 +02:00
|
|
|
close_many(p->auxiliary_fds, k);
|
2015-09-21 15:43:47 +02:00
|
|
|
p->auxiliary_fds = mfree(p->auxiliary_fds);
|
|
|
|
p->n_auxiliary_fds = 0;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2016-05-06 12:16:58 +02:00
|
|
|
static int socket_determine_selinux_label(Socket *s, char **ret) {
|
2018-03-09 12:20:56 +01:00
|
|
|
Service *service;
|
2016-05-06 12:16:58 +02:00
|
|
|
ExecCommand *c;
|
2018-03-28 09:00:42 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2016-05-06 12:16:58 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(ret);
|
|
|
|
|
|
|
|
if (s->selinux_context_from_net) {
|
|
|
|
/* If this is requested, get label from the network label */
|
|
|
|
|
|
|
|
r = mac_selinux_get_our_label(ret);
|
|
|
|
if (r == -EOPNOTSUPP)
|
|
|
|
goto no_label;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* Otherwise, get it from the executable we are about to start */
|
|
|
|
r = socket_instantiate_service(s);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (!UNIT_ISSET(s->service))
|
|
|
|
goto no_label;
|
|
|
|
|
2018-03-09 12:20:56 +01:00
|
|
|
service = SERVICE(UNIT_DEREF(s->service));
|
|
|
|
c = service->exec_command[SERVICE_EXEC_START];
|
2016-05-06 12:16:58 +02:00
|
|
|
if (!c)
|
|
|
|
goto no_label;
|
|
|
|
|
2018-03-28 09:00:42 +02:00
|
|
|
r = chase_symlinks(c->path, service->exec_context.root_directory, CHASE_PREFIX_ROOT, &path);
|
|
|
|
if (r < 0)
|
|
|
|
goto no_label;
|
|
|
|
|
2018-03-09 12:20:56 +01:00
|
|
|
r = mac_selinux_get_create_label_from_exe(path, ret);
|
2017-10-04 16:01:32 +02:00
|
|
|
if (IN_SET(r, -EPERM, -EOPNOTSUPP))
|
2016-05-06 12:16:58 +02:00
|
|
|
goto no_label;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
|
|
|
no_label:
|
|
|
|
*ret = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
static int socket_address_listen_do(
|
|
|
|
Socket *s,
|
|
|
|
const SocketAddress *address,
|
|
|
|
const char *label) {
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(address);
|
|
|
|
|
|
|
|
return socket_address_listen(
|
|
|
|
address,
|
|
|
|
SOCK_CLOEXEC|SOCK_NONBLOCK,
|
|
|
|
s->backlog,
|
|
|
|
s->bind_ipv6_only,
|
|
|
|
s->bind_to_device,
|
|
|
|
s->reuse_port,
|
|
|
|
s->free_bind,
|
|
|
|
s->transparent,
|
|
|
|
s->directory_mode,
|
|
|
|
s->socket_mode,
|
|
|
|
label);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_address_listen_in_cgroup(
|
|
|
|
Socket *s,
|
|
|
|
const SocketAddress *address,
|
|
|
|
const char *label) {
|
|
|
|
|
|
|
|
_cleanup_close_pair_ int pair[2] = { -1, -1 };
|
|
|
|
int fd, r;
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(address);
|
|
|
|
|
|
|
|
/* This is a wrapper around socket_address_listen(), that forks off a helper process inside the socket's cgroup
|
|
|
|
* in which the socket is actually created. This way we ensure the socket is actually properly attached to the
|
|
|
|
* unit's cgroup for the purpose of BPF filtering and such. */
|
|
|
|
|
|
|
|
if (!IN_SET(address->sockaddr.sa.sa_family, AF_INET, AF_INET6))
|
|
|
|
goto shortcut; /* BPF filtering only applies to IPv4 + IPv6, shortcut things for other protocols */
|
|
|
|
|
|
|
|
r = bpf_firewall_supported();
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2018-02-16 11:55:33 +01:00
|
|
|
if (r == BPF_FIREWALL_UNSUPPORTED) /* If BPF firewalling isn't supported anyway — there's no point in this forking complexity */
|
2017-09-07 11:17:43 +02:00
|
|
|
goto shortcut;
|
|
|
|
|
|
|
|
if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
|
|
|
|
|
2017-12-22 13:08:14 +01:00
|
|
|
r = unit_fork_helper_process(UNIT(s), "(sd-listen)", &pid);
|
2017-09-07 11:17:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), r, "Failed to fork off listener stub process: %m");
|
|
|
|
if (r == 0) {
|
|
|
|
/* Child */
|
|
|
|
|
|
|
|
pair[0] = safe_close(pair[0]);
|
|
|
|
|
|
|
|
fd = socket_address_listen_do(s, address, label);
|
|
|
|
if (fd < 0) {
|
|
|
|
log_unit_error_errno(UNIT(s), fd, "Failed to create listening socket: %m");
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = send_one_fd(pair[1], fd, 0);
|
|
|
|
if (r < 0) {
|
|
|
|
log_unit_error_errno(UNIT(s), r, "Failed to send listening socket to parent: %m");
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
_exit(EXIT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
pair[1] = safe_close(pair[1]);
|
|
|
|
fd = receive_one_fd(pair[0], 0);
|
|
|
|
|
|
|
|
/* We synchronously wait for the helper, as it shouldn't be slow */
|
2017-12-29 18:09:16 +01:00
|
|
|
r = wait_for_terminate_and_check("(sd-listen)", pid, WAIT_LOG_ABNORMAL);
|
2017-09-07 11:17:43 +02:00
|
|
|
if (r < 0) {
|
|
|
|
safe_close(fd);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), fd, "Failed to receive listening socket: %m");
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
|
|
|
|
shortcut:
|
|
|
|
fd = socket_address_listen_do(s, address, label);
|
|
|
|
if (fd < 0)
|
|
|
|
return log_error_errno(fd, "Failed to create listening socket: %m");
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
static int socket_open_fds(Socket *s) {
|
2015-09-23 19:55:49 +02:00
|
|
|
_cleanup_(mac_selinux_freep) char *label = NULL;
|
|
|
|
bool know_label = false;
|
2010-01-23 22:56:47 +01:00
|
|
|
SocketPort *p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
if (p->fd >= 0)
|
|
|
|
continue;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2015-09-23 19:58:59 +02:00
|
|
|
switch (p->type) {
|
|
|
|
|
|
|
|
case SOCKET_SOCKET:
|
2010-08-20 02:27:05 +02:00
|
|
|
|
2014-10-23 18:58:18 +02:00
|
|
|
if (!know_label) {
|
2016-05-06 12:16:58 +02:00
|
|
|
/* Figure out label, if we don't it know yet. We do it once, for the first socket where
|
|
|
|
* we need this and remember it for the rest. */
|
2014-10-23 18:58:18 +02:00
|
|
|
|
2016-05-06 12:16:58 +02:00
|
|
|
r = socket_determine_selinux_label(s, &label);
|
|
|
|
if (r < 0)
|
|
|
|
goto rollback;
|
2010-08-20 02:27:05 +02:00
|
|
|
|
|
|
|
know_label = true;
|
|
|
|
}
|
|
|
|
|
2015-11-16 07:45:47 +01:00
|
|
|
/* Apply the socket protocol */
|
2016-05-06 12:16:58 +02:00
|
|
|
switch (p->address.type) {
|
2016-05-05 13:45:18 +02:00
|
|
|
|
2015-11-16 07:45:47 +01:00
|
|
|
case SOCK_STREAM:
|
|
|
|
case SOCK_SEQPACKET:
|
2016-05-06 12:16:58 +02:00
|
|
|
if (s->socket_protocol == IPPROTO_SCTP)
|
|
|
|
p->address.protocol = s->socket_protocol;
|
2015-11-16 07:45:47 +01:00
|
|
|
break;
|
2016-05-05 13:45:18 +02:00
|
|
|
|
2015-11-16 07:45:47 +01:00
|
|
|
case SOCK_DGRAM:
|
2016-05-06 12:16:58 +02:00
|
|
|
if (s->socket_protocol == IPPROTO_UDPLITE)
|
|
|
|
p->address.protocol = s->socket_protocol;
|
2015-11-16 07:45:47 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
r = socket_address_listen_in_cgroup(s, &p->address, label);
|
2013-11-06 22:30:35 +01:00
|
|
|
if (r < 0)
|
2010-01-23 22:56:47 +01:00
|
|
|
goto rollback;
|
|
|
|
|
2013-11-06 22:30:35 +01:00
|
|
|
p->fd = r;
|
2010-07-01 00:29:17 +02:00
|
|
|
socket_apply_socket_options(s, p->fd);
|
2014-06-04 16:19:00 +02:00
|
|
|
socket_symlink(s);
|
2015-09-23 19:58:59 +02:00
|
|
|
break;
|
2010-07-01 00:29:17 +02:00
|
|
|
|
2015-09-23 19:58:59 +02:00
|
|
|
case SOCKET_SPECIAL:
|
2011-04-20 05:02:23 +02:00
|
|
|
|
2015-10-01 14:28:13 +02:00
|
|
|
p->fd = special_address_create(p->path, s->writable);
|
2015-09-23 19:52:23 +02:00
|
|
|
if (p->fd < 0) {
|
|
|
|
r = p->fd;
|
2011-04-20 05:02:23 +02:00
|
|
|
goto rollback;
|
2015-09-23 19:52:23 +02:00
|
|
|
}
|
2015-09-23 19:58:59 +02:00
|
|
|
break;
|
2011-04-20 05:02:23 +02:00
|
|
|
|
2015-09-23 19:58:59 +02:00
|
|
|
case SOCKET_FIFO:
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
p->fd = fifo_address_create(
|
2013-11-06 22:30:35 +01:00
|
|
|
p->path,
|
|
|
|
s->directory_mode,
|
2015-09-23 19:52:23 +02:00
|
|
|
s->socket_mode);
|
|
|
|
if (p->fd < 0) {
|
|
|
|
r = p->fd;
|
2010-01-23 22:56:47 +01:00
|
|
|
goto rollback;
|
2015-09-23 19:52:23 +02:00
|
|
|
}
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-07-16 19:42:27 +02:00
|
|
|
socket_apply_fifo_options(s, p->fd);
|
2014-06-04 16:19:00 +02:00
|
|
|
socket_symlink(s);
|
2015-09-23 19:58:59 +02:00
|
|
|
break;
|
2014-06-04 16:19:00 +02:00
|
|
|
|
2015-09-23 19:58:59 +02:00
|
|
|
case SOCKET_MQUEUE:
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2015-09-23 19:52:23 +02:00
|
|
|
p->fd = mq_address_create(
|
2013-11-06 22:30:35 +01:00
|
|
|
p->path,
|
|
|
|
s->socket_mode,
|
|
|
|
s->mq_maxmsg,
|
2015-09-23 19:52:23 +02:00
|
|
|
s->mq_msgsize);
|
|
|
|
if (p->fd < 0) {
|
|
|
|
r = p->fd;
|
2011-05-17 19:37:03 +02:00
|
|
|
goto rollback;
|
2015-09-23 19:52:23 +02:00
|
|
|
}
|
2015-09-23 19:58:59 +02:00
|
|
|
break;
|
2015-09-23 19:52:23 +02:00
|
|
|
|
2016-05-05 13:45:18 +02:00
|
|
|
case SOCKET_USB_FUNCTION: {
|
2016-03-22 12:08:42 +01:00
|
|
|
_cleanup_free_ char *ep = NULL;
|
2015-09-21 15:43:47 +02:00
|
|
|
|
2016-03-22 12:08:42 +01:00
|
|
|
ep = path_make_absolute("ep0", p->path);
|
|
|
|
|
|
|
|
p->fd = usbffs_address_create(ep);
|
2015-09-23 19:52:23 +02:00
|
|
|
if (p->fd < 0) {
|
|
|
|
r = p->fd;
|
2015-09-21 15:43:47 +02:00
|
|
|
goto rollback;
|
2015-09-23 19:52:23 +02:00
|
|
|
}
|
2015-09-21 15:43:47 +02:00
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
r = usbffs_write_descs(p->fd, SERVICE(UNIT_DEREF(s->service)));
|
2015-09-04 12:23:51 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto rollback;
|
|
|
|
|
2015-09-23 20:01:54 +02:00
|
|
|
r = usbffs_dispatch_eps(p);
|
2015-09-21 15:43:47 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto rollback;
|
2015-09-23 19:58:59 +02:00
|
|
|
|
|
|
|
break;
|
2016-03-22 12:08:42 +01:00
|
|
|
}
|
2015-09-23 19:58:59 +02:00
|
|
|
default:
|
2010-07-16 19:42:27 +02:00
|
|
|
assert_not_reached("Unknown port type");
|
2015-09-23 19:58:59 +02:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rollback:
|
|
|
|
socket_close_fds(s);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void socket_unwatch_fds(Socket *s) {
|
|
|
|
SocketPort *p;
|
2013-11-19 21:12:59 +01:00
|
|
|
int r;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(s);
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
if (p->fd < 0)
|
|
|
|
continue;
|
|
|
|
|
2014-06-05 12:24:03 +02:00
|
|
|
if (!p->event_source)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
|
|
|
|
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
|
|
|
log_unit_debug_errno(UNIT(s), r, "Failed to disable event source: %m");
|
2010-01-23 22:56:47 +01:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_watch_fds(Socket *s) {
|
|
|
|
SocketPort *p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
if (p->fd < 0)
|
|
|
|
continue;
|
|
|
|
|
2015-05-13 18:30:14 +02:00
|
|
|
if (p->event_source) {
|
2013-11-19 21:12:59 +01:00
|
|
|
r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
} else {
|
2014-02-19 23:54:58 +01:00
|
|
|
r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
|
2015-05-13 18:30:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2015-05-13 18:30:14 +02:00
|
|
|
(void) sd_event_source_set_description(p->event_source, "socket-port-io");
|
2013-11-19 21:12:59 +01:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-23 03:35:54 +01:00
|
|
|
return 0;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
fail:
|
2015-05-13 18:30:14 +02:00
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to watch listening fds: %m");
|
2010-01-26 04:18:44 +01:00
|
|
|
socket_unwatch_fds(s);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2016-05-06 13:01:17 +02:00
|
|
|
enum {
|
|
|
|
SOCKET_OPEN_NONE,
|
|
|
|
SOCKET_OPEN_SOME,
|
|
|
|
SOCKET_OPEN_ALL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int socket_check_open(Socket *s) {
|
|
|
|
bool have_open = false, have_closed = false;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
if (p->fd < 0)
|
|
|
|
have_closed = true;
|
|
|
|
else
|
|
|
|
have_open = true;
|
|
|
|
|
|
|
|
if (have_open && have_closed)
|
|
|
|
return SOCKET_OPEN_SOME;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (have_open)
|
|
|
|
return SOCKET_OPEN_ALL;
|
|
|
|
|
|
|
|
return SOCKET_OPEN_NONE;
|
|
|
|
}
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
static void socket_set_state(Socket *s, SocketState state) {
|
|
|
|
SocketState old_state;
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
old_state = s->state;
|
|
|
|
s->state = state;
|
|
|
|
|
2014-06-04 13:10:43 +02:00
|
|
|
if (!IN_SET(state,
|
|
|
|
SOCKET_START_PRE,
|
2014-06-05 09:55:53 +02:00
|
|
|
SOCKET_START_CHOWN,
|
2014-06-04 13:10:43 +02:00
|
|
|
SOCKET_START_POST,
|
|
|
|
SOCKET_STOP_PRE,
|
|
|
|
SOCKET_STOP_PRE_SIGTERM,
|
|
|
|
SOCKET_STOP_PRE_SIGKILL,
|
|
|
|
SOCKET_STOP_POST,
|
|
|
|
SOCKET_FINAL_SIGTERM,
|
|
|
|
SOCKET_FINAL_SIGKILL)) {
|
2013-11-19 21:12:59 +01:00
|
|
|
|
|
|
|
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
s->control_command = NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
|
2010-04-10 17:53:17 +02:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
if (state != SOCKET_LISTENING)
|
|
|
|
socket_unwatch_fds(s);
|
|
|
|
|
2014-06-04 13:10:43 +02:00
|
|
|
if (!IN_SET(state,
|
2014-06-05 09:55:53 +02:00
|
|
|
SOCKET_START_CHOWN,
|
2014-06-04 13:10:43 +02:00
|
|
|
SOCKET_START_POST,
|
|
|
|
SOCKET_LISTENING,
|
|
|
|
SOCKET_RUNNING,
|
|
|
|
SOCKET_STOP_PRE,
|
|
|
|
SOCKET_STOP_PRE_SIGTERM,
|
|
|
|
SOCKET_STOP_PRE_SIGKILL))
|
2010-01-26 04:18:44 +01:00
|
|
|
socket_close_fds(s);
|
|
|
|
|
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(s), "Changed %s -> %s", socket_state_to_string(old_state), socket_state_to_string(state));
|
2010-01-27 04:31:52 +01:00
|
|
|
|
2018-06-01 19:06:19 +02:00
|
|
|
unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], 0);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2015-04-24 15:27:19 +02:00
|
|
|
static int socket_coldplug(Unit *u) {
|
2010-04-21 03:27:44 +02:00
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(s->state == SOCKET_DEAD);
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (s->deserialized_state == s->state)
|
|
|
|
return 0;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2015-10-27 17:59:45 +01:00
|
|
|
if (s->control_pid > 0 &&
|
|
|
|
pid_is_unwaited(s->control_pid) &&
|
|
|
|
IN_SET(s->deserialized_state,
|
2014-06-05 09:55:53 +02:00
|
|
|
SOCKET_START_PRE,
|
|
|
|
SOCKET_START_CHOWN,
|
|
|
|
SOCKET_START_POST,
|
|
|
|
SOCKET_STOP_PRE,
|
|
|
|
SOCKET_STOP_PRE_SIGTERM,
|
|
|
|
SOCKET_STOP_PRE_SIGKILL,
|
|
|
|
SOCKET_STOP_POST,
|
|
|
|
SOCKET_FINAL_SIGTERM,
|
|
|
|
SOCKET_FINAL_SIGKILL)) {
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
r = unit_watch_pid(UNIT(s), s->control_pid);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-21 03:27:44 +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 = socket_arm_timer(s, usec_add(u->state_change_timestamp.monotonic, s->timeout_usec));
|
2013-12-02 23:30:19 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (IN_SET(s->deserialized_state,
|
|
|
|
SOCKET_START_CHOWN,
|
|
|
|
SOCKET_START_POST,
|
|
|
|
SOCKET_LISTENING,
|
2016-05-06 13:01:17 +02:00
|
|
|
SOCKET_RUNNING)) {
|
|
|
|
|
|
|
|
/* Originally, we used to simply reopen all sockets here that we didn't have file descriptors
|
|
|
|
* for. However, this is problematic, as we won't traverse throught the SOCKET_START_CHOWN state for
|
|
|
|
* them, and thus the UID/GID wouldn't be right. Hence, instead simply check if we have all fds open,
|
|
|
|
* and if there's a mismatch, warn loudly. */
|
|
|
|
|
|
|
|
r = socket_check_open(s);
|
|
|
|
if (r == SOCKET_OPEN_NONE)
|
|
|
|
log_unit_warning(UNIT(s),
|
|
|
|
"Socket unit configuration has changed while unit has been running, "
|
|
|
|
"no open socket file descriptor left. "
|
|
|
|
"The socket unit is not functional until restarted.");
|
|
|
|
else if (r == SOCKET_OPEN_SOME)
|
|
|
|
log_unit_warning(UNIT(s),
|
|
|
|
"Socket unit configuration has changed while unit has been running, "
|
|
|
|
"and some socket file descriptors have not been opened yet. "
|
|
|
|
"The socket unit is not fully functional until restarted.");
|
2013-12-02 23:30:19 +01:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
if (s->deserialized_state == SOCKET_LISTENING) {
|
|
|
|
r = socket_watch_fds(s);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2010-04-21 03:27:44 +02:00
|
|
|
}
|
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
if (!IN_SET(s->deserialized_state, SOCKET_DEAD, SOCKET_FAILED)) {
|
2016-07-14 12:37:28 +02:00
|
|
|
(void) unit_setup_dynamic_creds(u);
|
2018-02-06 08:00:34 +01:00
|
|
|
(void) unit_setup_exec_runtime(u);
|
|
|
|
}
|
2016-07-14 12:37:28 +02:00
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
socket_set_state(s, s->deserialized_state);
|
2010-04-21 03:27:44 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
|
2017-11-17 16:43:08 +01:00
|
|
|
|
2014-08-23 15:28:37 +02:00
|
|
|
ExecParameters exec_params = {
|
2018-07-17 11:47:14 +02:00
|
|
|
.flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
|
|
|
|
.stdin_fd = -1,
|
|
|
|
.stdout_fd = -1,
|
|
|
|
.stderr_fd = -1,
|
|
|
|
.exec_fd = -1,
|
2014-08-23 15:28:37 +02:00
|
|
|
};
|
2017-11-17 16:43:08 +01:00
|
|
|
pid_t pid;
|
|
|
|
int r;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(c);
|
|
|
|
assert(_pid);
|
|
|
|
|
2017-11-17 16:43:08 +01:00
|
|
|
r = unit_prepare_exec(UNIT(s));
|
2016-07-14 12:37:28 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
core: rework unit timeout handling, and add new setting RuntimeMaxSec=
This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as
indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code
(following the logic that 0 means "no", and USEC_INFINITY means "never").
This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated,
and sd-event considers it has indication for turning off the event source.
This also alters the deserialization of the units to restart timeouts from the time they were originally started from.
Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to
artificially prolonged timeouts if a daemon reload took place.
Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a
specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs.
This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is
removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn()
calls fail.
Fixes: #2249
2016-02-01 21:48:10 +01:00
|
|
|
r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->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-01-26 04:18:44 +01:00
|
|
|
|
2017-08-01 11:02:30 +02:00
|
|
|
unit_set_exec_params(UNIT(s), &exec_params);
|
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
|
|
|
|
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(s),
|
|
|
|
c,
|
2010-04-15 03:11:11 +02:00
|
|
|
&s->exec_context,
|
2014-08-23 15:28:37 +02:00
|
|
|
&exec_params,
|
2013-11-27 20:23:18 +01:00
|
|
|
s->exec_runtime,
|
2016-07-14 12:37:28 +02:00
|
|
|
&s->dynamic_creds,
|
2010-04-15 03:11:11 +02:00
|
|
|
&pid);
|
2014-06-18 20:34:52 +02: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-15 03:11:11 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
r = unit_watch_pid(UNIT(s), pid);
|
2010-04-15 03:11:11 +02:00
|
|
|
if (r < 0)
|
2014-06-05 09:55:53 +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-01-26 04:18:44 +01:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
*_pid = pid;
|
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
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_chown(Socket *s, pid_t *_pid) {
|
|
|
|
pid_t pid;
|
|
|
|
int 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 = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
|
2014-06-05 09:55:53 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* We have to resolve the user names out-of-process, hence
|
|
|
|
* let's fork here. It's messy, but well, what can we do? */
|
|
|
|
|
2017-12-22 13:08:14 +01:00
|
|
|
r = unit_fork_helper_process(UNIT(s), "(sd-chown)", &pid);
|
2017-09-07 11:17:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
if (r == 0) {
|
2014-11-28 20:51:01 +01:00
|
|
|
uid_t uid = UID_INVALID;
|
|
|
|
gid_t gid = GID_INVALID;
|
2017-09-07 11:17:43 +02:00
|
|
|
SocketPort *p;
|
2014-06-05 09:55:53 +02:00
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
/* Child */
|
2014-06-05 09:55:53 +02:00
|
|
|
|
|
|
|
if (!isempty(s->user)) {
|
|
|
|
const char *user = s->user;
|
|
|
|
|
|
|
|
r = get_user_creds(&user, &uid, &gid, NULL, NULL);
|
|
|
|
if (r < 0) {
|
2017-09-07 11:17:43 +02:00
|
|
|
log_unit_error_errno(UNIT(s), r, "Failed to resolve user %s: %m", user);
|
|
|
|
_exit(EXIT_USER);
|
2014-06-05 09:55:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!isempty(s->group)) {
|
|
|
|
const char *group = s->group;
|
|
|
|
|
|
|
|
r = get_group_creds(&group, &gid);
|
|
|
|
if (r < 0) {
|
2017-09-07 11:17:43 +02:00
|
|
|
log_unit_error_errno(UNIT(s), r, "Failed to resolve group %s: %m", group);
|
|
|
|
_exit(EXIT_GROUP);
|
2014-06-05 09:55:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
2014-06-06 23:29:09 +02:00
|
|
|
const char *path = NULL;
|
2014-06-05 09:55:53 +02:00
|
|
|
|
|
|
|
if (p->type == SOCKET_SOCKET)
|
|
|
|
path = socket_address_get_path(&p->address);
|
|
|
|
else if (p->type == SOCKET_FIFO)
|
|
|
|
path = p->path;
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (chown(path, uid, gid) < 0) {
|
2017-09-07 11:17:43 +02:00
|
|
|
log_unit_error_errno(UNIT(s), errno, "Failed to chown(): %m");
|
|
|
|
_exit(EXIT_CHOWN);
|
2014-06-05 09:55:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
_exit(EXIT_SUCCESS);
|
2014-06-05 09:55:53 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = unit_watch_pid(UNIT(s), pid);
|
|
|
|
if (r < 0)
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
*_pid = pid;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2013-11-19 21:12:59 +01:00
|
|
|
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
|
2010-01-23 22:56:47 +01:00
|
|
|
return r;
|
2010-01-23 03:35:54 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_enter_dead(Socket *s, SocketResult f) {
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(s);
|
|
|
|
|
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 (s->result == SOCKET_SUCCESS)
|
2012-02-03 02:31:54 +01:00
|
|
|
s->result = f;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2017-09-26 23:35:58 +02:00
|
|
|
if (s->result != SOCKET_SUCCESS)
|
|
|
|
log_unit_warning(UNIT(s), "Failed with result '%s'.", socket_result_to_string(s->result));
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
|
|
|
|
|
2018-02-06 08:00:34 +01:00
|
|
|
s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
|
2013-11-27 20:23:18 +01:00
|
|
|
|
core: add {State,Cache,Log,Configuration}Directory= (#6384)
This introduces {State,Cache,Log,Configuration}Directory= those are
similar to RuntimeDirectory=. They create the directories under
/var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode
specified in {State,Cache,Log,Configuration}DirectoryMode=.
This also fixes #6391.
2017-07-18 14:34:52 +02:00
|
|
|
exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->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(s), true);
|
|
|
|
|
2016-07-14 12:37:28 +02:00
|
|
|
dynamic_creds_destroy(&s->dynamic_creds);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
|
2010-04-13 02:06:27 +02:00
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_enter_stop_post(Socket *s, SocketResult f) {
|
2010-01-26 04:18:44 +01:00
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
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 (s->result == SOCKET_SUCCESS)
|
2012-02-03 02:31:54 +01:00
|
|
|
s->result = f;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command_id = SOCKET_EXEC_STOP_POST;
|
2014-06-05 09:55:53 +02:00
|
|
|
s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST];
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (s->control_command) {
|
|
|
|
r = socket_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
if (r < 0)
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
socket_set_state(s, SOCKET_STOP_POST);
|
|
|
|
} else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
|
2010-01-26 04:18:44 +01: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(s), r, "Failed to run 'stop-post' task: %m");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
|
2010-01-26 04:18:44 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
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 (s->result == SOCKET_SUCCESS)
|
2012-02-03 02:31:54 +01:00
|
|
|
s->result = f;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2013-01-26 05:53:30 +01:00
|
|
|
r = unit_kill_context(
|
|
|
|
UNIT(s),
|
|
|
|
&s->kill_context,
|
2017-09-29 09:58:22 +02:00
|
|
|
!IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_FINAL_SIGTERM) ?
|
2014-10-28 16:35:40 +01:00
|
|
|
KILL_KILL : KILL_TERMINATE,
|
2013-01-26 05:53:30 +01:00
|
|
|
-1,
|
|
|
|
s->control_pid,
|
|
|
|
false);
|
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
2010-01-26 04:18:44 +01: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 = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
|
2012-11-23 21:37:58 +01:00
|
|
|
if (r < 0)
|
2010-04-13 02:06:27 +02:00
|
|
|
goto fail;
|
2010-01-28 01:59:41 +01:00
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
socket_set_state(s, state);
|
2014-01-29 14:58:04 +01:00
|
|
|
} else if (state == SOCKET_STOP_PRE_SIGTERM)
|
|
|
|
socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
|
|
|
|
else if (state == SOCKET_STOP_PRE_SIGKILL)
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_SUCCESS);
|
2014-01-29 14:58:04 +01:00
|
|
|
else if (state == SOCKET_FINAL_SIGTERM)
|
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
|
2010-04-13 02:06:27 +02:00
|
|
|
else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_SUCCESS);
|
2010-01-26 04:18:44 +01: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(s), r, "Failed to kill processes: %m");
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2017-09-29 00:37:23 +02:00
|
|
|
if (IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_STOP_PRE_SIGKILL))
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_enter_stop_pre(Socket *s, SocketResult f) {
|
2010-01-26 04:18:44 +01:00
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
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 (s->result == SOCKET_SUCCESS)
|
2012-02-03 02:31:54 +01:00
|
|
|
s->result = f;
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command_id = SOCKET_EXEC_STOP_PRE;
|
2014-06-05 09:55:53 +02:00
|
|
|
s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE];
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (s->control_command) {
|
|
|
|
r = socket_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
if (r < 0)
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
socket_set_state(s, SOCKET_STOP_PRE);
|
|
|
|
} else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_SUCCESS);
|
2010-01-26 04:18:44 +01: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(s), r, "Failed to run 'stop-pre' task: %m");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2010-01-27 05:33:11 +01:00
|
|
|
static void socket_enter_listening(Socket *s) {
|
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
r = socket_watch_fds(s);
|
|
|
|
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
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to watch sockets: %m");
|
2010-01-27 05:33:11 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket_set_state(s, SOCKET_LISTENING);
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-27 05:33:11 +01:00
|
|
|
}
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
static void socket_enter_start_post(Socket *s) {
|
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
|
|
|
s->control_command_id = SOCKET_EXEC_START_POST;
|
|
|
|
s->control_command = s->exec_command[SOCKET_EXEC_START_POST];
|
|
|
|
|
|
|
|
if (s->control_command) {
|
|
|
|
r = socket_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
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
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
|
2014-06-05 09:55:53 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket_set_state(s, SOCKET_START_POST);
|
|
|
|
} else
|
|
|
|
socket_enter_listening(s);
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void socket_enter_start_chown(Socket *s) {
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
r = socket_open_fds(s);
|
|
|
|
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
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to listen on sockets: %m");
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (!isempty(s->user) || !isempty(s->group)) {
|
2010-04-11 00:22:36 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
|
|
|
s->control_command_id = SOCKET_EXEC_START_CHOWN;
|
|
|
|
s->control_command = NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
r = socket_chown(s, &s->control_pid);
|
2012-02-03 02:31:54 +01:00
|
|
|
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
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to fork 'start-chown' task: %m");
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_set_state(s, SOCKET_START_CHOWN);
|
2010-04-13 02:06:27 +02:00
|
|
|
} else
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_enter_start_post(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void socket_enter_start_pre(Socket *s) {
|
|
|
|
int r;
|
|
|
|
assert(s);
|
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
2017-11-24 22:02:22 +01:00
|
|
|
|
|
|
|
unit_warn_leftover_processes(UNIT(s));
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command_id = SOCKET_EXEC_START_PRE;
|
2014-06-05 09:55:53 +02:00
|
|
|
s->control_command = s->exec_command[SOCKET_EXEC_START_PRE];
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
if (s->control_command) {
|
2013-12-02 23:30:19 +01:00
|
|
|
r = socket_spawn(s, s->control_command, &s->control_pid);
|
2014-06-05 09:55:53 +02:00
|
|
|
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
|
|
|
log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
2014-06-05 09:55:53 +02:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
socket_set_state(s, SOCKET_START_PRE);
|
|
|
|
} else
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_enter_start_chown(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2016-05-06 13:29:26 +02:00
|
|
|
static void flush_ports(Socket *s) {
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
/* Flush all incoming traffic, regardless if actual bytes or new connections, so that this socket isn't busy
|
|
|
|
* anymore */
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
if (p->fd < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
(void) flush_accept(p->fd);
|
|
|
|
(void) flush_fd(p->fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
static void socket_enter_running(Socket *s, int cfd) {
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
|
2010-01-26 04:18:44 +01:00
|
|
|
int r;
|
|
|
|
|
2016-04-26 20:26:15 +02:00
|
|
|
/* Note that this call takes possession of the connection fd passed. It either has to assign it somewhere or
|
|
|
|
* close it. */
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(s);
|
|
|
|
|
2016-05-06 13:29:26 +02:00
|
|
|
/* We don't take connections anymore if we are supposed to shut down anyway */
|
2013-04-26 02:57:41 +02:00
|
|
|
if (unit_stop_pending(UNIT(s))) {
|
2013-12-02 23:30:19 +01: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
|
|
|
log_unit_debug(UNIT(s), "Suppressing connection request since unit stop is scheduled.");
|
2011-01-26 02:55:35 +01:00
|
|
|
|
2010-07-13 00:51:48 +02:00
|
|
|
if (cfd >= 0)
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2016-05-06 13:29:26 +02:00
|
|
|
else
|
|
|
|
flush_ports(s);
|
2010-07-13 00:51:48 +02:00
|
|
|
|
2010-07-13 00:27:27 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-05-11 11:16:52 +02:00
|
|
|
if (!ratelimit_below(&s->trigger_limit)) {
|
2016-04-26 20:26:15 +02:00
|
|
|
log_unit_warning(UNIT(s), "Trigger limit hit, refusing further activation.");
|
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_TRIGGER_LIMIT_HIT);
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2016-04-26 20:26:15 +02:00
|
|
|
}
|
|
|
|
|
2010-04-15 06:19:54 +02:00
|
|
|
if (cfd < 0) {
|
2010-10-05 19:49:15 +02:00
|
|
|
bool pending = false;
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
Unit *other;
|
|
|
|
Iterator i;
|
|
|
|
void *v;
|
2010-10-05 19:49:15 +02:00
|
|
|
|
|
|
|
/* If there's already a start pending don't bother to
|
|
|
|
* do anything */
|
core: track why unit dependencies came to be
This replaces the dependencies Set* objects by Hashmap* objects, where
the key is the depending Unit, and the value is a bitmask encoding why
the specific dependency was created.
The bitmask contains a number of different, defined bits, that indicate
why dependencies exist, for example whether they are created due to
explicitly configured deps in files, by udev rules or implicitly.
Note that memory usage is not increased by this change, even though we
store more information, as we manage to encode the bit mask inside the
value pointer each Hashmap entry contains.
Why this all? When we know how a dependency came to be, we can update
dependencies correctly when a configuration source changes but others
are left unaltered. Specifically:
1. We can fix UDEV_WANTS dependency generation: so far we kept adding
dependencies configured that way, but if a device lost such a
dependency we couldn't them again as there was no scheme for removing
of dependencies in place.
2. We can implement "pin-pointed" reload of unit files. If we know what
dependencies were created as result of configuration in a unit file,
then we know what to flush out when we want to reload it.
3. It's useful for debugging: "systemd-analyze dump" now shows
this information, helping substantially with understanding how
systemd's dependency tree came to be the way it came to be.
2017-10-25 20:46:01 +02:00
|
|
|
HASHMAP_FOREACH_KEY(v, other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
|
2013-12-02 23:30:19 +01:00
|
|
|
if (unit_active_or_pending(other)) {
|
2012-01-06 23:08:54 +01:00
|
|
|
pending = true;
|
|
|
|
break;
|
|
|
|
}
|
2010-10-05 19:49:15 +02:00
|
|
|
|
2012-01-20 23:44:22 +01:00
|
|
|
if (!pending) {
|
2014-05-22 09:56:21 +02:00
|
|
|
if (!UNIT_ISSET(s->service)) {
|
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(s), "Service to activate vanished, refusing activation.");
|
2014-05-22 09:56:21 +02:00
|
|
|
r = -ENOENT;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2015-11-12 19:52:31 +01:00
|
|
|
r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, &error, NULL);
|
2012-01-20 23:44:22 +01:00
|
|
|
if (r < 0)
|
2010-10-05 19:49:15 +02:00
|
|
|
goto fail;
|
2012-01-20 23:44:22 +01:00
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
|
|
|
|
socket_set_state(s, SOCKET_RUNNING);
|
|
|
|
} else {
|
2013-11-16 22:18:12 +01:00
|
|
|
_cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
|
2016-08-02 19:48:23 +02:00
|
|
|
_cleanup_(socket_peer_unrefp) SocketPeer *p = NULL;
|
2010-07-16 19:42:27 +02:00
|
|
|
Service *service;
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2010-06-19 04:25:28 +02:00
|
|
|
if (s->n_connections >= s->max_connections) {
|
2016-08-05 05:51:47 +02:00
|
|
|
log_unit_warning(UNIT(s), "Too many incoming connections (%u), dropping connection.",
|
2016-08-05 03:42:23 +02:00
|
|
|
s->n_connections);
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2010-06-19 04:25:28 +02:00
|
|
|
}
|
|
|
|
|
2016-08-02 19:48:23 +02:00
|
|
|
if (s->max_connections_per_source > 0) {
|
2016-08-05 03:42:23 +02:00
|
|
|
r = socket_acquire_peer(s, cfd, &p);
|
2016-08-02 19:48:23 +02:00
|
|
|
if (r < 0) {
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2016-08-05 03:42:23 +02:00
|
|
|
} else if (r > 0 && p->n_ref > s->max_connections_per_source) {
|
2016-08-05 05:51:47 +02:00
|
|
|
_cleanup_free_ char *t = NULL;
|
|
|
|
|
2016-12-29 11:21:37 +01:00
|
|
|
(void) sockaddr_pretty(&p->peer.sa, p->peer_salen, true, false, &t);
|
2016-08-05 05:51:47 +02:00
|
|
|
|
2016-08-05 03:42:23 +02:00
|
|
|
log_unit_warning(UNIT(s),
|
2016-08-05 05:51:47 +02:00
|
|
|
"Too many incoming connections (%u) from source %s, dropping connection.",
|
|
|
|
p->n_ref, strnull(t));
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2016-08-02 19:48:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-20 23:44:22 +01:00
|
|
|
r = socket_instantiate_service(s);
|
|
|
|
if (r < 0)
|
2010-07-16 19:42:27 +02:00
|
|
|
goto fail;
|
|
|
|
|
2012-01-20 23:44:22 +01:00
|
|
|
r = instance_from_socket(cfd, s->n_accepted, &instance);
|
|
|
|
if (r < 0) {
|
|
|
|
if (r != -ENOTCONN)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* ENOTCONN is legitimate if TCP RST was received.
|
|
|
|
* This connection is over, but the socket unit lives on. */
|
2016-04-26 20:26:15 +02:00
|
|
|
log_unit_debug(UNIT(s), "Got ENOTCONN on incoming socket, assuming aborted connection attempt, ignoring.");
|
2018-06-11 12:56:26 +02:00
|
|
|
goto refuse;
|
2012-01-20 23:44:22 +01:00
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_to_prefix(UNIT(s)->id, &prefix);
|
|
|
|
if (r < 0)
|
2010-04-15 06:19:54 +02:00
|
|
|
goto fail;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_build(prefix, instance, ".service", &name);
|
|
|
|
if (r < 0)
|
2010-05-20 20:46:17 +02:00
|
|
|
goto fail;
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2012-01-20 23:44:22 +01:00
|
|
|
r = unit_add_name(UNIT_DEREF(s->service), name);
|
2013-11-16 22:18:12 +01:00
|
|
|
if (r < 0)
|
2010-04-15 06:19:54 +02:00
|
|
|
goto fail;
|
2010-07-16 19:42:27 +02:00
|
|
|
|
2012-01-06 23:08:54 +01:00
|
|
|
service = SERVICE(UNIT_DEREF(s->service));
|
|
|
|
unit_ref_unset(&s->service);
|
2010-08-11 02:07:59 +02:00
|
|
|
|
2016-04-29 11:14:03 +02:00
|
|
|
s->n_accepted++;
|
2010-07-16 19:42:27 +02:00
|
|
|
unit_choose_id(UNIT(service), name);
|
|
|
|
|
2014-07-24 10:40:28 +02:00
|
|
|
r = service_set_socket_fd(service, cfd, s, s->selinux_context_from_net);
|
2012-01-20 23:44:22 +01:00
|
|
|
if (r < 0)
|
2010-04-15 06:19:54 +02:00
|
|
|
goto fail;
|
|
|
|
|
2016-04-26 20:26:15 +02:00
|
|
|
cfd = -1; /* We passed ownership of the fd to the service now. Forget it here. */
|
2016-02-23 05:32:04 +01:00
|
|
|
s->n_connections++;
|
2010-06-19 04:25:28 +02:00
|
|
|
|
2018-04-05 07:26:26 +02:00
|
|
|
service->peer = TAKE_PTR(p); /* Pass ownership of the peer reference */
|
2016-08-02 19:48:23 +02:00
|
|
|
|
2015-11-12 19:52:31 +01:00
|
|
|
r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, &error, NULL);
|
2016-04-28 17:09:50 +02:00
|
|
|
if (r < 0) {
|
|
|
|
/* We failed to activate the new service, but it still exists. Let's make sure the service
|
|
|
|
* closes and forgets the connection fd again, immediately. */
|
|
|
|
service_close_socket_fd(service);
|
2010-04-15 06:19:54 +02:00
|
|
|
goto fail;
|
2016-04-28 17:09:50 +02:00
|
|
|
}
|
2010-08-20 02:26:05 +02:00
|
|
|
|
|
|
|
/* Notify clients about changed counters */
|
|
|
|
unit_add_to_dbus_queue(UNIT(s));
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
2018-06-11 12:56:26 +02:00
|
|
|
refuse:
|
|
|
|
s->n_refused++;
|
|
|
|
safe_close(cfd);
|
|
|
|
return;
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
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(UNIT(s), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
|
|
|
|
cfd >= 0 ? "template" : "non-template",
|
2013-11-19 21:12:59 +01:00
|
|
|
bus_error_message(&error, r));
|
2013-12-02 23:30:19 +01:00
|
|
|
|
2012-04-02 21:49:00 +02:00
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(cfd);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static void socket_run_next(Socket *s) {
|
2010-01-26 04:18:44 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(s->control_command);
|
|
|
|
assert(s->control_command->command_next);
|
|
|
|
|
2010-04-11 00:22:36 +02:00
|
|
|
socket_unwatch_control_pid(s);
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
s->control_command = s->control_command->command_next;
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
r = socket_spawn(s, s->control_command, &s->control_pid);
|
|
|
|
if (r < 0)
|
2010-01-26 04:18:44 +01:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
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(s), r, "Failed to run next task: %m");
|
2010-04-13 02:06:27 +02:00
|
|
|
|
|
|
|
if (s->state == SOCKET_START_POST)
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
else if (s->state == SOCKET_STOP_POST)
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
static int socket_start(Unit *u) {
|
|
|
|
Socket *s = SOCKET(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-01-23 22:56:47 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
/* We cannot fulfill this request right now, try again later
|
|
|
|
* please! */
|
2014-06-05 09:55:53 +02:00
|
|
|
if (IN_SET(s->state,
|
|
|
|
SOCKET_STOP_PRE,
|
|
|
|
SOCKET_STOP_PRE_SIGKILL,
|
|
|
|
SOCKET_STOP_PRE_SIGTERM,
|
|
|
|
SOCKET_STOP_POST,
|
|
|
|
SOCKET_FINAL_SIGTERM,
|
|
|
|
SOCKET_FINAL_SIGKILL))
|
2010-01-26 04:18:44 +01:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2014-06-05 12:24:03 +02:00
|
|
|
/* Already on it! */
|
2014-06-05 09:55:53 +02:00
|
|
|
if (IN_SET(s->state,
|
|
|
|
SOCKET_START_PRE,
|
|
|
|
SOCKET_START_CHOWN,
|
|
|
|
SOCKET_START_POST))
|
2010-01-26 04:18:44 +01:00
|
|
|
return 0;
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
/* Cannot run this without the service being around */
|
2013-06-20 03:45:08 +02:00
|
|
|
if (UNIT_ISSET(s->service)) {
|
2012-01-06 23:08:54 +01:00
|
|
|
Service *service;
|
|
|
|
|
|
|
|
service = SERVICE(UNIT_DEREF(s->service));
|
|
|
|
|
2012-01-15 12:25:20 +01:00
|
|
|
if (UNIT(service)->load_state != UNIT_LOADED) {
|
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(u, "Socket service %s not loaded, refusing.", UNIT(service)->id);
|
2010-04-15 06:19:54 +02:00
|
|
|
return -ENOENT;
|
2011-04-10 03:27:19 +02:00
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
|
2011-02-21 15:32:17 +01:00
|
|
|
/* If the service is already active we cannot start the
|
2010-04-15 06:19:54 +02:00
|
|
|
* socket */
|
2017-09-29 09:58:22 +02:00
|
|
|
if (!IN_SET(service->state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
|
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(u, "Socket service %s already active, refusing.", UNIT(service)->id);
|
2010-04-15 06:19:54 +02:00
|
|
|
return -EBUSY;
|
2011-04-10 03:27:19 +02:00
|
|
|
}
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
2010-04-10 17:53:17 +02:00
|
|
|
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(s->state, SOCKET_DEAD, SOCKET_FAILED));
|
2010-01-23 22:56:47 +01: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) {
|
|
|
|
socket_enter_dead(s, SOCKET_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 02:31:54 +01:00
|
|
|
s->result = SOCKET_SUCCESS;
|
2018-07-17 19:36:46 +02:00
|
|
|
exec_command_reset_status_list_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
|
2017-11-17 16:43:08 +01:00
|
|
|
|
|
|
|
u->reset_accounting = true;
|
2015-03-01 16:24:19 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
socket_enter_start_pre(s);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-01-26 04:18:44 +01:00
|
|
|
}
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
static int socket_stop(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2010-04-10 17:53:17 +02:00
|
|
|
/* Already on it */
|
2014-06-05 09:55:53 +02:00
|
|
|
if (IN_SET(s->state,
|
|
|
|
SOCKET_STOP_PRE,
|
|
|
|
SOCKET_STOP_PRE_SIGTERM,
|
|
|
|
SOCKET_STOP_PRE_SIGKILL,
|
|
|
|
SOCKET_STOP_POST,
|
|
|
|
SOCKET_FINAL_SIGTERM,
|
|
|
|
SOCKET_FINAL_SIGKILL))
|
2010-04-10 17:53:17 +02:00
|
|
|
return 0;
|
|
|
|
|
2010-07-10 04:52:00 +02:00
|
|
|
/* If there's already something running we go directly into
|
|
|
|
* kill mode. */
|
2014-06-05 09:55:53 +02:00
|
|
|
if (IN_SET(s->state,
|
|
|
|
SOCKET_START_PRE,
|
|
|
|
SOCKET_START_CHOWN,
|
|
|
|
SOCKET_START_POST)) {
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
|
2010-07-10 04:52:00 +02:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2017-09-29 00:37:23 +02:00
|
|
|
assert(IN_SET(s->state, SOCKET_LISTENING, SOCKET_RUNNING));
|
2010-01-23 22:56:47 +01:00
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, SOCKET_SUCCESS);
|
2015-01-28 15:07:13 +01:00
|
|
|
return 1;
|
2010-01-23 03:35:54 +01:00
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
SocketPort *p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(f);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
|
2012-02-03 02:31:54 +01:00
|
|
|
unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
|
2010-04-21 03:27:44 +02:00
|
|
|
unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
|
2018-06-11 12:56:26 +02:00
|
|
|
unit_serialize_item_format(u, f, "n-refused", "%u", s->n_refused);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
if (s->control_pid > 0)
|
2014-04-25 13:45:15 +02:00
|
|
|
unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
if (s->control_command_id >= 0)
|
|
|
|
unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
int copy;
|
|
|
|
|
|
|
|
if (p->fd < 0)
|
|
|
|
continue;
|
|
|
|
|
2013-11-27 20:23:18 +01:00
|
|
|
copy = fdset_put_dup(fds, p->fd);
|
|
|
|
if (copy < 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
return copy;
|
|
|
|
|
|
|
|
if (p->type == SOCKET_SOCKET) {
|
2013-11-27 20:23:18 +01:00
|
|
|
_cleanup_free_ char *t = NULL;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-12-22 19:25:10 +01:00
|
|
|
r = socket_address_print(&p->address, &t);
|
|
|
|
if (r < 0)
|
2010-04-21 03:27:44 +02:00
|
|
|
return r;
|
|
|
|
|
2011-04-10 03:27:00 +02:00
|
|
|
if (socket_address_family(&p->address) == AF_NETLINK)
|
|
|
|
unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
|
|
|
|
else
|
|
|
|
unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
|
2013-11-27 20:23:18 +01:00
|
|
|
|
2011-04-20 05:02:23 +02:00
|
|
|
} else if (p->type == SOCKET_SPECIAL)
|
|
|
|
unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
|
2012-12-22 19:25:10 +01:00
|
|
|
else if (p->type == SOCKET_MQUEUE)
|
|
|
|
unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
|
2015-09-21 15:43:47 +02:00
|
|
|
else if (p->type == SOCKET_USB_FUNCTION)
|
|
|
|
unit_serialize_item_format(u, f, "ffs", "%i %s", copy, p->path);
|
2011-04-20 05:02:23 +02:00
|
|
|
else {
|
2010-04-21 03:27:44 +02:00
|
|
|
assert(p->type == SOCKET_FIFO);
|
|
|
|
unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-05 14:24:00 +02:00
|
|
|
static void socket_port_take_fd(SocketPort *p, FDSet *fds, int fd) {
|
|
|
|
safe_close(p->fd);
|
|
|
|
p->fd = fdset_remove(fds, fd);
|
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(key);
|
|
|
|
assert(value);
|
|
|
|
|
|
|
|
if (streq(key, "state")) {
|
|
|
|
SocketState state;
|
|
|
|
|
2012-12-22 19:25:10 +01:00
|
|
|
state = socket_state_from_string(value);
|
|
|
|
if (state < 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
|
|
|
|
s->deserialized_state = state;
|
2012-02-03 02:31:54 +01:00
|
|
|
} else if (streq(key, "result")) {
|
|
|
|
SocketResult f;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
f = socket_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 02:31:54 +01:00
|
|
|
else if (f != SOCKET_SUCCESS)
|
|
|
|
s->result = f;
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
} else if (streq(key, "n-accepted")) {
|
|
|
|
unsigned k;
|
|
|
|
|
2010-08-11 22:04:22 +02:00
|
|
|
if (safe_atou(value, &k) < 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 n-accepted value: %s", value);
|
2010-04-21 03:27:44 +02:00
|
|
|
else
|
|
|
|
s->n_accepted += k;
|
2018-06-11 12:56:26 +02:00
|
|
|
} else if (streq(key, "n-refused")) {
|
|
|
|
unsigned k;
|
|
|
|
|
|
|
|
if (safe_atou(value, &k) < 0)
|
|
|
|
log_unit_debug(u, "Failed to parse n-refused value: %s", value);
|
|
|
|
else
|
|
|
|
s->n_refused += k;
|
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
|
|
|
s->control_pid = pid;
|
2010-04-21 03:27:44 +02:00
|
|
|
} else if (streq(key, "control-command")) {
|
|
|
|
SocketExecCommand id;
|
|
|
|
|
2013-01-05 18:00:35 +01:00
|
|
|
id = socket_exec_command_from_string(value);
|
|
|
|
if (id < 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 exec-command value: %s", value);
|
2010-04-21 03:27:44 +02:00
|
|
|
else {
|
|
|
|
s->control_command_id = id;
|
|
|
|
s->control_command = s->exec_command[id];
|
|
|
|
}
|
|
|
|
} else if (streq(key, "fifo")) {
|
|
|
|
int fd, skip = 0;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
|
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 fifo value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2010-04-21 03:27:44 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
2011-04-20 05:02:23 +02:00
|
|
|
if (p->type == SOCKET_FIFO &&
|
2017-06-17 18:37:16 +02:00
|
|
|
path_equal_or_files_same(p->path, value+skip, 0)) {
|
2016-08-05 14:24:00 +02:00
|
|
|
socket_port_take_fd(p, fds, fd);
|
2011-04-20 05:02:23 +02:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2011-04-20 05:02:23 +02:00
|
|
|
|
|
|
|
} else if (streq(key, "special")) {
|
|
|
|
int fd, skip = 0;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
|
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 special value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2011-04-20 05:02:23 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
|
|
|
if (p->type == SOCKET_SPECIAL &&
|
2017-06-17 18:37:16 +02:00
|
|
|
path_equal_or_files_same(p->path, value+skip, 0)) {
|
2016-08-05 14:24:00 +02:00
|
|
|
socket_port_take_fd(p, fds, fd);
|
2010-04-21 03:27:44 +02:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2012-12-22 19:25:10 +01:00
|
|
|
} else if (streq(key, "mqueue")) {
|
|
|
|
int fd, skip = 0;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
|
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 mqueue value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2012-12-22 19:25:10 +01:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
|
|
|
if (p->type == SOCKET_MQUEUE &&
|
2016-08-05 14:24:00 +02:00
|
|
|
streq(p->path, value+skip)) {
|
|
|
|
socket_port_take_fd(p, fds, fd);
|
2012-12-22 19:25:10 +01:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2012-12-22 19:25:10 +01:00
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
} else if (streq(key, "socket")) {
|
2010-06-05 00:52:30 +02:00
|
|
|
int fd, type, skip = 0;
|
2010-04-21 03:27:44 +02:00
|
|
|
SocketPort *p;
|
|
|
|
|
2010-06-05 00:52:30 +02:00
|
|
|
if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
|
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 socket value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2010-04-21 03:27:44 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
2016-08-05 14:24:00 +02:00
|
|
|
if (socket_address_is(&p->address, value+skip, type)) {
|
|
|
|
socket_port_take_fd(p, fds, fd);
|
2010-04-21 03:27:44 +02:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2011-04-10 03:27:00 +02:00
|
|
|
} else if (streq(key, "netlink")) {
|
|
|
|
int fd, skip = 0;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
|
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 socket value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2011-04-10 03:27:00 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
2016-08-05 14:24:00 +02:00
|
|
|
if (socket_address_is_netlink(&p->address, value+skip)) {
|
|
|
|
socket_port_take_fd(p, fds, fd);
|
2011-04-10 03:27:00 +02:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2015-09-21 15:43:47 +02:00
|
|
|
|
|
|
|
} else if (streq(key, "ffs")) {
|
|
|
|
int fd, skip = 0;
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
|
|
|
|
log_unit_debug(u, "Failed to parse ffs value: %s", value);
|
2016-08-05 14:24:00 +02:00
|
|
|
else
|
2015-09-21 15:43:47 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports)
|
|
|
|
if (p->type == SOCKET_USB_FUNCTION &&
|
2017-06-17 18:37:16 +02:00
|
|
|
path_equal_or_files_same(p->path, value+skip, 0)) {
|
2016-08-05 14:24:00 +02:00
|
|
|
socket_port_take_fd(p, fds, fd);
|
2015-09-21 15:43:47 +02:00
|
|
|
break;
|
2016-08-05 14:24:00 +02:00
|
|
|
}
|
2015-09-21 15:43:47 +02:00
|
|
|
|
2010-04-21 03:27:44 +02: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_debug(UNIT(s), "Unknown serialization key: %s", key);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-10 20:42:58 +01:00
|
|
|
static void socket_distribute_fds(Unit *u, FDSet *fds) {
|
2012-12-22 19:30:07 +01:00
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
SocketPort *p;
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
|
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
|
|
|
Iterator i;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (p->type != SOCKET_SOCKET)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (p->fd >= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
FDSET_FOREACH(fd, fds, i) {
|
|
|
|
if (socket_address_matches_fd(&p->address, fd)) {
|
|
|
|
p->fd = fdset_remove(fds, fd);
|
|
|
|
s->deserialized_state = SOCKET_LISTENING;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static UnitActiveState socket_active_state(Unit *u) {
|
2010-01-26 21:39:06 +01:00
|
|
|
assert(u);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-01-27 04:31:52 +01:00
|
|
|
return state_translation_table[SOCKET(u)->state];
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2013-05-03 04:51:50 +02:00
|
|
|
_pure_ static const char *socket_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 socket_state_to_string(SOCKET(u)->state);
|
2010-04-13 20:59:01 +02:00
|
|
|
}
|
|
|
|
|
2013-04-01 22:09:45 +02:00
|
|
|
const char* socket_port_type_to_string(SocketPort *p) {
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
|
|
|
switch (p->type) {
|
2013-11-19 21:12:59 +01:00
|
|
|
|
|
|
|
case SOCKET_SOCKET:
|
|
|
|
|
|
|
|
switch (p->address.type) {
|
|
|
|
|
|
|
|
case SOCK_STREAM:
|
|
|
|
return "Stream";
|
|
|
|
|
|
|
|
case SOCK_DGRAM:
|
|
|
|
return "Datagram";
|
|
|
|
|
|
|
|
case SOCK_SEQPACKET:
|
|
|
|
return "SequentialPacket";
|
|
|
|
|
|
|
|
case SOCK_RAW:
|
|
|
|
if (socket_address_family(&p->address) == AF_NETLINK)
|
|
|
|
return "Netlink";
|
|
|
|
|
2017-11-19 19:06:10 +01:00
|
|
|
_fallthrough_;
|
2013-11-19 21:12:59 +01:00
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SOCKET_SPECIAL:
|
|
|
|
return "Special";
|
|
|
|
|
|
|
|
case SOCKET_MQUEUE:
|
|
|
|
return "MessageQueue";
|
|
|
|
|
|
|
|
case SOCKET_FIFO:
|
|
|
|
return "FIFO";
|
|
|
|
|
2015-09-21 15:43:47 +02:00
|
|
|
case SOCKET_USB_FUNCTION:
|
|
|
|
return "USBFunction";
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
default:
|
|
|
|
return NULL;
|
2013-04-01 22:09:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-23 08:29:40 +01:00
|
|
|
SocketType socket_port_type_from_string(const char *s) {
|
|
|
|
assert(s);
|
|
|
|
|
2017-12-23 11:32:04 +01:00
|
|
|
if (STR_IN_SET(s, "Stream", "Datagram", "SequentialPacket", "Netlink"))
|
|
|
|
return SOCKET_SOCKET;
|
|
|
|
else if (streq(s, "Special"))
|
|
|
|
return SOCKET_SPECIAL;
|
|
|
|
else if (streq(s, "MessageQueue"))
|
|
|
|
return SOCKET_MQUEUE;
|
|
|
|
else if (streq(s, "FIFO"))
|
|
|
|
return SOCKET_FIFO;
|
|
|
|
else if (streq(s, "USBFunction"))
|
|
|
|
return SOCKET_USB_FUNCTION;
|
2017-12-23 08:29:40 +01:00
|
|
|
else
|
|
|
|
return _SOCKET_TYPE_INVALID;
|
|
|
|
}
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
_pure_ static bool socket_may_gc(Unit *u) {
|
2010-06-19 04:25:28 +02:00
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
return s->n_connections == 0;
|
2010-06-19 04:25:28 +02:00
|
|
|
}
|
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
static int socket_accept_do(Socket *s, int fd) {
|
|
|
|
int cfd;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(fd >= 0);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
|
|
|
|
if (cfd < 0) {
|
|
|
|
if (errno == EINTR)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cfd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_accept_in_cgroup(Socket *s, SocketPort *p, int fd) {
|
|
|
|
_cleanup_close_pair_ int pair[2] = { -1, -1 };
|
|
|
|
int cfd, r;
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(p);
|
|
|
|
assert(fd >= 0);
|
|
|
|
|
|
|
|
/* Similar to socket_address_listen_in_cgroup(), but for accept() rathern than socket(): make sure that any
|
|
|
|
* connection socket is also properly associated with the cgroup. */
|
|
|
|
|
|
|
|
if (!IN_SET(p->address.sockaddr.sa.sa_family, AF_INET, AF_INET6))
|
|
|
|
goto shortcut;
|
|
|
|
|
|
|
|
r = bpf_firewall_supported();
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2018-02-16 11:55:33 +01:00
|
|
|
if (r == BPF_FIREWALL_UNSUPPORTED)
|
2017-09-07 11:17:43 +02:00
|
|
|
goto shortcut;
|
|
|
|
|
|
|
|
if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
|
|
|
|
|
2017-12-22 13:08:14 +01:00
|
|
|
r = unit_fork_helper_process(UNIT(s), "(sd-accept)", &pid);
|
2017-09-07 11:17:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), r, "Failed to fork off accept stub process: %m");
|
|
|
|
if (r == 0) {
|
|
|
|
/* Child */
|
|
|
|
|
|
|
|
pair[0] = safe_close(pair[0]);
|
|
|
|
|
|
|
|
cfd = socket_accept_do(s, fd);
|
|
|
|
if (cfd < 0) {
|
|
|
|
log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = send_one_fd(pair[1], cfd, 0);
|
|
|
|
if (r < 0) {
|
|
|
|
log_unit_error_errno(UNIT(s), r, "Failed to send connection socket to parent: %m");
|
|
|
|
_exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
_exit(EXIT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
pair[1] = safe_close(pair[1]);
|
|
|
|
cfd = receive_one_fd(pair[0], 0);
|
|
|
|
|
|
|
|
/* We synchronously wait for the helper, as it shouldn't be slow */
|
2017-12-29 18:09:16 +01:00
|
|
|
r = wait_for_terminate_and_check("(sd-accept)", pid, WAIT_LOG_ABNORMAL);
|
2017-09-07 11:17:43 +02:00
|
|
|
if (r < 0) {
|
|
|
|
safe_close(cfd);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cfd < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), cfd, "Failed to receive connection socket: %m");
|
|
|
|
|
|
|
|
return cfd;
|
|
|
|
|
|
|
|
shortcut:
|
|
|
|
cfd = socket_accept_do(s, fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
return log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
|
|
|
|
|
|
|
|
return cfd;
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
|
|
|
|
SocketPort *p = userdata;
|
2010-04-15 06:19:54 +02:00
|
|
|
int cfd = -1;
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(p);
|
2010-04-16 23:24:39 +02:00
|
|
|
assert(fd >= 0);
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (p->socket->state != SOCKET_LISTENING)
|
|
|
|
return 0;
|
2010-05-24 01:45:54 +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
|
|
|
log_unit_debug(UNIT(p->socket), "Incoming traffic");
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (revents != EPOLLIN) {
|
2011-04-26 21:39:14 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (revents & EPOLLHUP)
|
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(p->socket), "Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.");
|
2011-04-26 21:39:14 +02: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_error(UNIT(p->socket), "Got unexpected poll event (0x%x) on socket.", revents);
|
2010-04-16 23:24:39 +02:00
|
|
|
goto fail;
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
if (p->socket->accept &&
|
|
|
|
p->type == SOCKET_SOCKET &&
|
|
|
|
socket_address_can_accept(&p->address)) {
|
|
|
|
|
2017-09-07 11:17:43 +02:00
|
|
|
cfd = socket_accept_in_cgroup(p->socket, p, fd);
|
|
|
|
if (cfd < 0)
|
|
|
|
goto fail;
|
2010-07-01 00:29:17 +02:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
socket_apply_socket_options(p->socket, cfd);
|
2010-04-15 06:19:54 +02:00
|
|
|
}
|
2010-01-24 00:39:29 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
socket_enter_running(p->socket, cfd);
|
|
|
|
return 0;
|
2010-04-16 23:24:39 +02:00
|
|
|
|
|
|
|
fail:
|
2013-11-19 21:12:59 +01:00
|
|
|
socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
|
|
|
|
return 0;
|
2010-01-24 00:39:29 +01:00
|
|
|
}
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
|
|
|
|
Socket *s = SOCKET(u);
|
2012-02-03 02:31:54 +01:00
|
|
|
SocketResult f;
|
2010-01-23 01:52:57 +01:00
|
|
|
|
|
|
|
assert(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(pid >= 0);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-06-16 05:10:31 +02:00
|
|
|
if (pid != s->control_pid)
|
|
|
|
return;
|
2010-01-23 03:35:54 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
s->control_pid = 0;
|
|
|
|
|
2016-10-10 22:07:30 +02:00
|
|
|
if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
|
2012-02-03 02:31:54 +01:00
|
|
|
f = SOCKET_SUCCESS;
|
|
|
|
else if (code == CLD_EXITED)
|
|
|
|
f = SOCKET_FAILURE_EXIT_CODE;
|
|
|
|
else if (code == CLD_KILLED)
|
|
|
|
f = SOCKET_FAILURE_SIGNAL;
|
|
|
|
else if (code == CLD_DUMPED)
|
|
|
|
f = SOCKET_FAILURE_CORE_DUMP;
|
|
|
|
else
|
2014-06-05 12:24:03 +02:00
|
|
|
assert_not_reached("Unknown sigchld code");
|
2010-06-16 05:10:31 +02:00
|
|
|
|
2010-07-12 02:25:42 +02:00
|
|
|
if (s->control_command) {
|
2011-05-18 01:07:31 +02:00
|
|
|
exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2017-08-01 10:16:42 +02:00
|
|
|
if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
|
2012-02-03 02:31:54 +01:00
|
|
|
f = SOCKET_SUCCESS;
|
2010-07-12 02:25:42 +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
|
|
|
log_unit_full(u, f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
|
|
|
|
"Control process exited, code=%s status=%i",
|
|
|
|
sigchld_code_to_string(code), status);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
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 (s->result == SOCKET_SUCCESS)
|
2012-02-03 02:31:54 +01:00
|
|
|
s->result = f;
|
|
|
|
|
|
|
|
if (s->control_command &&
|
|
|
|
s->control_command->command_next &&
|
|
|
|
f == SOCKET_SUCCESS) {
|
|
|
|
|
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, "Running next command for state %s", socket_state_to_string(s->state));
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_run_next(s);
|
2010-01-27 04:31:52 +01:00
|
|
|
} else {
|
2010-04-21 03:27:44 +02:00
|
|
|
s->control_command = NULL;
|
|
|
|
s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
/* No further commands for this step, so let's figure
|
|
|
|
* out what to do next */
|
2010-01-23 01:52:57 +01: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
|
|
|
log_unit_debug(u, "Got final SIGCHLD for state %s", socket_state_to_string(s->state));
|
2010-01-27 04:31:52 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
switch (s->state) {
|
|
|
|
|
|
|
|
case SOCKET_START_PRE:
|
2012-02-03 02:31:54 +01:00
|
|
|
if (f == SOCKET_SUCCESS)
|
2014-06-05 09:55:53 +02:00
|
|
|
socket_enter_start_chown(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
case SOCKET_START_CHOWN:
|
|
|
|
if (f == SOCKET_SUCCESS)
|
|
|
|
socket_enter_start_post(s);
|
|
|
|
else
|
|
|
|
socket_enter_stop_pre(s, f);
|
|
|
|
break;
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
case SOCKET_START_POST:
|
2012-02-03 02:31:54 +01:00
|
|
|
if (f == SOCKET_SUCCESS)
|
2010-01-27 05:33:11 +01:00
|
|
|
socket_enter_listening(s);
|
2010-01-26 04:18:44 +01:00
|
|
|
else
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, f);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_PRE:
|
|
|
|
case SOCKET_STOP_PRE_SIGTERM:
|
|
|
|
case SOCKET_STOP_PRE_SIGKILL:
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, f);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_POST:
|
2010-04-13 02:06:27 +02:00
|
|
|
case SOCKET_FINAL_SIGTERM:
|
|
|
|
case SOCKET_FINAL_SIGKILL:
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, f);
|
2010-01-26 04:18:44 +01: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-01-26 04:18:44 +01:00
|
|
|
}
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
|
|
|
|
Socket *s = SOCKET(userdata);
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
assert(s);
|
2013-11-19 21:12:59 +01:00
|
|
|
assert(s->timer_event_source == source);
|
2010-01-26 04:18:44 +01:00
|
|
|
|
|
|
|
switch (s->state) {
|
|
|
|
|
|
|
|
case SOCKET_START_PRE:
|
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(s), "Starting timed out. Terminating.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
|
2011-03-31 15:35:40 +02:00
|
|
|
break;
|
2010-04-13 02:06:27 +02:00
|
|
|
|
2014-06-05 09:55:53 +02:00
|
|
|
case SOCKET_START_CHOWN:
|
2010-01-26 04:18:44 +01:00
|
|
|
case SOCKET_START_POST:
|
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(s), "Starting timed out. Stopping.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_PRE:
|
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(s), "Stopping timed out. Terminating.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_PRE_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
if (s->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(s), "Stopping timed out. Killing.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_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(s), "Stopping timed out. Skipping SIGKILL. Ignoring.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_PRE_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(s), "Processes still around after SIGKILL. Ignoring.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOCKET_STOP_POST:
|
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(s), "Stopping timed out (2). Terminating.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
case SOCKET_FINAL_SIGTERM:
|
2012-07-19 23:47:10 +02:00
|
|
|
if (s->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(s), "Stopping timed out (2). Killing.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_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(s), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
|
2011-01-18 22:55:54 +01:00
|
|
|
}
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
2010-04-13 02:06:27 +02:00
|
|
|
case SOCKET_FINAL_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(s), "Still around after SIGKILL (2). Entering failed mode.");
|
2012-02-03 02:31:54 +01:00
|
|
|
socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
|
2010-01-26 04:18:44 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Timeout at wrong time.");
|
|
|
|
}
|
2013-11-19 21:12:59 +01:00
|
|
|
|
|
|
|
return 0;
|
2010-01-23 01:52:57 +01:00
|
|
|
}
|
|
|
|
|
2015-10-03 16:41:36 +02:00
|
|
|
int socket_collect_fds(Socket *s, int **fds) {
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
size_t k = 0, n = 0;
|
2010-01-26 07:02:51 +01:00
|
|
|
SocketPort *p;
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
int *rfds;
|
2010-01-26 07:02:51 +01:00
|
|
|
|
|
|
|
assert(s);
|
|
|
|
assert(fds);
|
|
|
|
|
|
|
|
/* Called from the service code for requesting our fds */
|
|
|
|
|
2015-09-21 16:30:41 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
2010-01-26 07:02:51 +01:00
|
|
|
if (p->fd >= 0)
|
2015-10-03 16:41:36 +02:00
|
|
|
n++;
|
|
|
|
n += p->n_auxiliary_fds;
|
2015-09-21 16:30:41 +02:00
|
|
|
}
|
2010-01-26 07:02:51 +01:00
|
|
|
|
2015-10-03 16:41:36 +02:00
|
|
|
if (n <= 0) {
|
2011-09-23 02:39:28 +02:00
|
|
|
*fds = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-03 16:41:36 +02:00
|
|
|
rfds = new(int, n);
|
2015-04-07 18:47:35 +02:00
|
|
|
if (!rfds)
|
2010-01-26 07:02:51 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-09-21 16:30:41 +02:00
|
|
|
LIST_FOREACH(port, p, s->ports) {
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
size_t i;
|
2015-10-03 16:41:36 +02:00
|
|
|
|
2010-01-26 07:02:51 +01:00
|
|
|
if (p->fd >= 0)
|
|
|
|
rfds[k++] = p->fd;
|
2015-09-21 16:30:41 +02:00
|
|
|
for (i = 0; i < p->n_auxiliary_fds; ++i)
|
|
|
|
rfds[k++] = p->auxiliary_fds[i];
|
|
|
|
}
|
2010-01-26 07:02:51 +01:00
|
|
|
|
2015-10-03 16:41:36 +02:00
|
|
|
assert(k == n);
|
2010-01-26 07:02:51 +01:00
|
|
|
|
|
|
|
*fds = rfds;
|
tree-wide: be more careful with the type of array sizes
Previously we were a bit sloppy with the index and size types of arrays,
we'd regularly use unsigned. While I don't think this ever resulted in
real issues I think we should be more careful there and follow a
stricter regime: unless there's a strong reason not to use size_t for
array sizes and indexes, size_t it should be. Any allocations we do
ultimately will use size_t anyway, and converting forth and back between
unsigned and size_t will always be a source of problems.
Note that on 32bit machines "unsigned" and "size_t" are equivalent, and
on 64bit machines our arrays shouldn't grow that large anyway, and if
they do we have a problem, however that kind of overly large allocation
we have protections for usually, but for overflows we do not have that
so much, hence let's add it.
So yeah, it's a story of the current code being already "good enough",
but I think some extra type hygiene is better.
This patch tries to be comprehensive, but it probably isn't and I missed
a few cases. But I guess we can cover that later as we notice it. Among
smaller fixes, this changes:
1. strv_length()' return type becomes size_t
2. the unit file changes array size becomes size_t
3. DNS answer and query array sizes become size_t
Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=76745
2018-04-27 14:09:31 +02:00
|
|
|
return (int) n;
|
2010-01-26 07:02:51 +01:00
|
|
|
}
|
|
|
|
|
2013-12-02 23:30:19 +01:00
|
|
|
static void socket_reset_failed(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
if (s->state == SOCKET_FAILED)
|
|
|
|
socket_set_state(s, SOCKET_DEAD);
|
|
|
|
|
|
|
|
s->result = SOCKET_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2010-06-19 04:25:28 +02:00
|
|
|
void socket_connection_unref(Socket *s) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
/* The service is dead. Yay!
|
|
|
|
*
|
2011-02-21 15:32:17 +01:00
|
|
|
* This is strictly for one-instance-per-connection
|
2010-06-19 04:25:28 +02:00
|
|
|
* services. */
|
|
|
|
|
|
|
|
assert(s->n_connections > 0);
|
|
|
|
s->n_connections--;
|
|
|
|
|
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(s), "One connection closed, %u left.", s->n_connections);
|
2010-07-18 04:58:01 +02:00
|
|
|
}
|
|
|
|
|
2013-07-22 10:52:53 +02:00
|
|
|
static void socket_trigger_notify(Unit *u, Unit *other) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(u);
|
|
|
|
assert(other);
|
|
|
|
|
2016-05-02 16:41:41 +02:00
|
|
|
/* Filter out invocations with bogus state */
|
|
|
|
if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Don't propagate state changes from the service if we are already down */
|
|
|
|
if (!IN_SET(s->state, SOCKET_RUNNING, SOCKET_LISTENING))
|
2013-07-22 10:52:53 +02:00
|
|
|
return;
|
|
|
|
|
2016-05-02 16:41:41 +02:00
|
|
|
/* We don't care for the service state if we are in Accept=yes mode */
|
|
|
|
if (s->accept)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Propagate start limit hit state */
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
if (other->start_limit_hit) {
|
|
|
|
socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_START_LIMIT_HIT);
|
2013-07-22 10:52:53 +02:00
|
|
|
return;
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
}
|
2013-07-22 10:52:53 +02:00
|
|
|
|
2016-05-02 16:41:41 +02:00
|
|
|
/* Don't propagate anything if there's still a job queued */
|
|
|
|
if (other->job)
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
return;
|
2013-07-22 10:52:53 +02:00
|
|
|
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
if (IN_SET(SERVICE(other)->state,
|
|
|
|
SERVICE_DEAD, SERVICE_FAILED,
|
|
|
|
SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
|
|
|
|
SERVICE_AUTO_RESTART))
|
|
|
|
socket_enter_listening(s);
|
2013-07-22 10:52:53 +02:00
|
|
|
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
if (SERVICE(other)->state == SERVICE_RUNNING)
|
2013-07-22 10:52:53 +02:00
|
|
|
socket_set_state(s, SOCKET_RUNNING);
|
|
|
|
}
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
static int socket_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, SOCKET(u)->control_pid, error);
|
2010-10-22 16:11:50 +02:00
|
|
|
}
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
static int socket_get_timeout(Unit *u, usec_t *timeout) {
|
2014-01-27 06:57:34 +01:00
|
|
|
Socket *s = SOCKET(u);
|
2016-02-04 00:35:43 +01:00
|
|
|
usec_t t;
|
2014-01-27 06:57:34 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!s->timer_event_source)
|
|
|
|
return 0;
|
|
|
|
|
2016-02-04 00:35:43 +01:00
|
|
|
r = sd_event_source_get_time(s->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;
|
|
|
|
}
|
|
|
|
|
2015-10-04 17:36:19 +02:00
|
|
|
char *socket_fdname(Socket *s) {
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
/* Returns the name to use for $LISTEN_NAMES. If the user
|
|
|
|
* didn't specify anything specifically, use the socket unit's
|
|
|
|
* name as fallback. */
|
|
|
|
|
2017-12-19 12:12:01 +01:00
|
|
|
return s->fdname ?: UNIT(s)->id;
|
2015-10-04 17:36:19 +02:00
|
|
|
}
|
|
|
|
|
2016-04-20 15:28:28 +02:00
|
|
|
static int socket_control_pid(Unit *u) {
|
|
|
|
Socket *s = SOCKET(u);
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
|
|
|
return s->control_pid;
|
|
|
|
}
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
|
2017-12-19 14:14:07 +01:00
|
|
|
[SOCKET_EXEC_START_PRE] = "ExecStartPre",
|
|
|
|
[SOCKET_EXEC_START_CHOWN] = "ExecStartChown",
|
|
|
|
[SOCKET_EXEC_START_POST] = "ExecStartPost",
|
|
|
|
[SOCKET_EXEC_STOP_PRE] = "ExecStopPre",
|
|
|
|
[SOCKET_EXEC_STOP_POST] = "ExecStopPost"
|
2010-04-21 03:27:44 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
|
|
|
|
|
2012-02-03 02:31:54 +01:00
|
|
|
static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
|
|
|
|
[SOCKET_SUCCESS] = "success",
|
|
|
|
[SOCKET_FAILURE_RESOURCES] = "resources",
|
|
|
|
[SOCKET_FAILURE_TIMEOUT] = "timeout",
|
|
|
|
[SOCKET_FAILURE_EXIT_CODE] = "exit-code",
|
|
|
|
[SOCKET_FAILURE_SIGNAL] = "signal",
|
2012-03-05 22:47:54 +01:00
|
|
|
[SOCKET_FAILURE_CORE_DUMP] = "core-dump",
|
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
|
|
|
[SOCKET_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
|
2016-04-26 20:26:15 +02:00
|
|
|
[SOCKET_FAILURE_TRIGGER_LIMIT_HIT] = "trigger-limit-hit",
|
core: make the StartLimitXYZ= settings generic and apply to any kind of unit, not just services
This moves the StartLimitBurst=, StartLimitInterval=, StartLimitAction=, RebootArgument= from the [Service] section
into the [Unit] section of unit files, and thus support it in all unit types, not just in services.
This way we can enforce the start limit much earlier, in particular before testing the unit conditions, so that
repeated start-up failure due to failed conditions is also considered for the start limit logic.
For compatibility the four options may also be configured in the [Service] section still, but we only document them in
their new section [Unit].
This also renamed the socket unit failure code "service-failed-permanent" into "service-start-limit-hit" to express
more clearly what it is about, after all it's only triggered through the start limit being hit.
Finally, the code in busname_trigger_notify() and socket_trigger_notify() is altered to become more alike.
Fixes: #2467
2016-02-09 18:38:03 +01:00
|
|
|
[SOCKET_FAILURE_SERVICE_START_LIMIT_HIT] = "service-start-limit-hit"
|
2012-02-03 02:31:54 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
|
|
|
|
|
2010-01-26 21:39:06 +01:00
|
|
|
const UnitVTable socket_vtable = {
|
2012-01-15 10:53:49 +01:00
|
|
|
.object_size = sizeof(Socket),
|
2013-11-19 21:12:59 +01:00
|
|
|
.exec_context_offset = offsetof(Socket, exec_context),
|
|
|
|
.cgroup_context_offset = offsetof(Socket, cgroup_context),
|
|
|
|
.kill_context_offset = offsetof(Socket, kill_context),
|
2013-11-27 20:23:18 +01:00
|
|
|
.exec_runtime_offset = offsetof(Socket, exec_runtime),
|
2016-07-14 12:37:28 +02:00
|
|
|
.dynamic_creds_offset = offsetof(Socket, dynamic_creds),
|
2012-09-18 11:40:01 +02:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
.sections =
|
|
|
|
"Unit\0"
|
|
|
|
"Socket\0"
|
|
|
|
"Install\0",
|
2013-06-27 04:14:27 +02:00
|
|
|
.private_section = "Socket",
|
2013-01-19 01:01:41 +01:00
|
|
|
|
2017-12-23 10:47:33 +01:00
|
|
|
.can_transient = true,
|
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
.init = socket_init,
|
|
|
|
.done = socket_done,
|
2010-04-21 03:27:44 +02:00
|
|
|
.load = socket_load,
|
|
|
|
|
|
|
|
.coldplug = socket_coldplug,
|
2010-01-26 04:18:44 +01:00
|
|
|
|
2010-01-23 01:52:57 +01:00
|
|
|
.dump = socket_dump,
|
|
|
|
|
2010-01-23 03:35:54 +01:00
|
|
|
.start = socket_start,
|
|
|
|
.stop = socket_stop,
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
.kill = socket_kill,
|
|
|
|
|
2014-01-27 06:57:34 +01:00
|
|
|
.get_timeout = socket_get_timeout,
|
|
|
|
|
2010-04-21 03:27:44 +02:00
|
|
|
.serialize = socket_serialize,
|
|
|
|
.deserialize_item = socket_deserialize_item,
|
2012-12-22 19:30:07 +01:00
|
|
|
.distribute_fds = socket_distribute_fds,
|
2010-04-21 03:27:44 +02:00
|
|
|
|
2010-01-23 01:52:57 +01:00
|
|
|
.active_state = socket_active_state,
|
2010-04-13 20:59:01 +02:00
|
|
|
.sub_state_to_string = socket_sub_state_to_string,
|
2010-01-23 01:52:57 +01:00
|
|
|
|
2018-02-13 10:50:13 +01:00
|
|
|
.may_gc = socket_may_gc,
|
2010-06-19 04:25:28 +02:00
|
|
|
|
2010-01-26 04:18:44 +01:00
|
|
|
.sigchld_event = socket_sigchld_event,
|
2010-04-18 03:08:16 +02:00
|
|
|
|
2013-07-22 10:52:53 +02:00
|
|
|
.trigger_notify = socket_trigger_notify,
|
|
|
|
|
2010-08-31 00:23:34 +02:00
|
|
|
.reset_failed = socket_reset_failed,
|
2010-07-18 04:58:01 +02:00
|
|
|
|
2016-04-20 15:28:28 +02:00
|
|
|
.control_pid = socket_control_pid,
|
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
.bus_vtable = bus_socket_vtable,
|
2013-06-27 23:21:21 +02:00
|
|
|
.bus_set_property = bus_socket_set_property,
|
|
|
|
.bus_commit_properties = bus_socket_commit_properties,
|
2012-05-13 18:18:54 +02:00
|
|
|
|
|
|
|
.status_message_formats = {
|
|
|
|
/*.starting_stopping = {
|
|
|
|
[0] = "Starting socket %s...",
|
|
|
|
[1] = "Stopping socket %s...",
|
|
|
|
},*/
|
|
|
|
.finished_start_job = {
|
|
|
|
[JOB_DONE] = "Listening on %s.",
|
|
|
|
[JOB_FAILED] = "Failed to listen on %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out starting %s.",
|
|
|
|
},
|
|
|
|
.finished_stop_job = {
|
|
|
|
[JOB_DONE] = "Closed %s.",
|
|
|
|
[JOB_FAILED] = "Failed stopping %s.",
|
|
|
|
[JOB_TIMEOUT] = "Timed out stopping %s.",
|
|
|
|
},
|
|
|
|
},
|
2010-01-23 01:52:57 +01:00
|
|
|
};
|