static int slice_verify(Slice *s) {
_cleanup_free_ char *parent = NULL;
int r;
assert(s);
if (UNIT(s)->load_state != UNIT_LOADED)
return 0;
if (!slice_name_is_valid(UNIT(s)->id)) {
log_unit_error(UNIT(s), "Slice name %s is not valid. Refusing.", UNIT(s)->id);
return -EINVAL;
}
r = slice_build_parent_slice(UNIT(s)->id, &parent);
if (r < 0)
return log_unit_error_errno(UNIT(s), r, "Failed to determine parent slice: %m");
if (parent ? !unit_has_name(UNIT_DEREF(UNIT(s)->slice), parent) : UNIT_ISSET(UNIT(s)->slice)) {
log_unit_error(UNIT(s), "Located outside of parent slice. Refusing.");
return -EINVAL;
}
return 0;
}
static int automount_start(Unit *u) {
Automount *a = AUTOMOUNT(u);
Unit *trigger;
int r;
assert(a);
assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_FAILED);
if (path_is_mount_point(a->where, NULL, 0) > 0) {
log_unit_error(u, "Path %s is already a mount point, refusing start.", a->where);
return -EEXIST;
}
trigger = UNIT_TRIGGER(u);
if (!trigger || trigger->load_state != UNIT_LOADED) {
log_unit_error(u, "Refusing to start, unit to trigger not loaded.");
return -ENOENT;
}
r = unit_start_limit_test(u);
if (r < 0) {
automount_enter_dead(a, AUTOMOUNT_FAILURE_START_LIMIT_HIT);
return r;
}
r = unit_acquire_invocation_id(u);
if (r < 0)
return r;
a->result = AUTOMOUNT_SUCCESS;
automount_enter_waiting(a);
return 1;
}
static int automount_verify(Automount *a) {
_cleanup_free_ char *e = NULL;
int r;
assert(a);
if (UNIT(a)->load_state != UNIT_LOADED)
return 0;
if (path_equal(a->where, "/")) {
log_unit_error(UNIT(a), "Cannot have an automount unit for the root directory. Refusing.");
return -EINVAL;
}
r = unit_name_from_path(a->where, ".automount", &e);
if (r < 0)
return log_unit_error(UNIT(a), "Failed to generate unit name from path: %m");
if (!unit_has_name(UNIT(a), e)) {
log_unit_error(UNIT(a), "Where= setting doesn't match unit name. Refusing.");
return -EINVAL;
}
return 0;
}
static void automount_enter_running(Automount *a) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
Unit *trigger;
struct stat st;
int r;
assert(a);
/* If the user masked our unit in the meantime, fail */
if (UNIT(a)->load_state != UNIT_LOADED) {
log_unit_error(UNIT(a), "Suppressing automount event since unit is no longer loaded.");
goto fail;
}
/* We don't take mount requests anymore if we are supposed to
* shut down anyway */
if (unit_stop_pending(UNIT(a))) {
log_unit_debug(UNIT(a), "Suppressing automount request since unit stop is scheduled.");
automount_send_ready(a, a->tokens, -EHOSTDOWN);
automount_send_ready(a, a->expire_tokens, -EHOSTDOWN);
return;
}
mkdir_p_label(a->where, a->directory_mode);
/* Before we do anything, let's see if somebody is playing games with us? */
if (lstat(a->where, &st) < 0) {
log_unit_warning_errno(UNIT(a), errno, "Failed to stat automount point: %m");
goto fail;
}
/* The mount unit may have been explicitly started before we got the
* autofs request. Ack it to unblock anything waiting on the mount point. */
if (!S_ISDIR(st.st_mode) || st.st_dev != a->dev_id) {
log_unit_info(UNIT(a), "Automount point already active?");
automount_send_ready(a, a->tokens, 0);
return;
}
trigger = UNIT_TRIGGER(UNIT(a));
if (!trigger) {
log_unit_error(UNIT(a), "Unit to trigger vanished.");
goto fail;
}
r = manager_add_job(UNIT(a)->manager, JOB_START, trigger, JOB_REPLACE, &error, NULL);
if (r < 0) {
log_unit_warning(UNIT(a), "Failed to queue mount startup job: %s", bus_error_message(&error, r));
goto fail;
}
automount_set_state(a, AUTOMOUNT_RUNNING);
return;
fail:
automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
}
static int slice_verify(Slice *s) {
assert(s);
if (UNIT(s)->load_state != UNIT_LOADED)
return 0;
if (UNIT_DEREF(UNIT(s)->slice)) {
char *a, *dash;
a = strdupa(UNIT(s)->id);
dash = strrchr(a, '-');
if (dash)
strcpy(dash, ".slice");
else
a = (char*) SPECIAL_ROOT_SLICE;
if (!unit_has_name(UNIT_DEREF(UNIT(s)->slice), a)) {
log_unit_error(UNIT(s)->id,
"%s located outside its parent slice. Refusing.", UNIT(s)->id);
return -EINVAL;
}
}
return 0;
}
static int busname_start(Unit *u) {
BusName *n = BUSNAME(u);
assert(n);
/* We cannot fulfill this request right now, try again later
* please! */
if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
return -EAGAIN;
/* Already on it! */
if (n->state == BUSNAME_MAKING)
return 0;
if (n->activating && UNIT_ISSET(n->service)) {
Service *service;
service = SERVICE(UNIT_DEREF(n->service));
if (UNIT(service)->load_state != UNIT_LOADED) {
log_unit_error(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
return -ENOENT;
}
}
assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
n->result = BUSNAME_SUCCESS;
busname_enter_making(n);
return 1;
}
static int busname_verify(BusName *n) {
char *e;
assert(n);
if (UNIT(n)->load_state != UNIT_LOADED)
return 0;
if (!service_name_is_valid(n->name)) {
log_unit_error(UNIT(n)->id, "%s's Name= setting is not a valid service name Refusing.", UNIT(n)->id);
return -EINVAL;
}
e = strjoina(n->name, ".busname");
if (!unit_has_name(UNIT(n), e)) {
log_unit_error(UNIT(n)->id, "%s's Name= setting doesn't match unit name. Refusing.", UNIT(n)->id);
return -EINVAL;
}
return 0;
}
static void busname_enter_running(BusName *n) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
bool pending = false;
Unit *other;
Iterator i;
int r;
assert(n);
if (!n->activating)
return;
/* We don't take connections anymore if we are supposed to
* shut down anyway */
if (unit_stop_pending(UNIT(n))) {
log_unit_debug(UNIT(n), "Suppressing activation request since unit stop is scheduled.");
/* Flush all queued activation reqeuest by closing and reopening the connection */
bus_kernel_drop_one(n->starter_fd);
busname_enter_listening(n);
return;
}
/* If there's already a start pending don't bother to do
* anything */
SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
if (unit_active_or_pending(other)) {
pending = true;
break;
}
if (!pending) {
if (!UNIT_ISSET(n->service)) {
log_unit_error(UNIT(n), "Service to activate vanished, refusing activation.");
r = -ENOENT;
goto fail;
}
r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, &error, NULL);
if (r < 0)
goto fail;
}
busname_set_state(n, BUSNAME_RUNNING);
return;
fail:
log_unit_warning(UNIT(n), "Failed to queue service startup job: %s", bus_error_message(&error, r));
busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
}
static int scope_verify(Scope *s) {
assert(s);
if (UNIT(s)->load_state != UNIT_LOADED)
return 0;
if (set_isempty(UNIT(s)->pids) && UNIT(s)->manager->n_reloading <= 0) {
log_unit_error(UNIT(s), "Scope has no PIDs. Refusing.");
return -EINVAL;
}
return 0;
}
static int scope_verify(Scope *s) {
assert(s);
if (UNIT(s)->load_state != UNIT_LOADED)
return 0;
if (set_isempty(UNIT(s)->pids) &&
!MANAGER_IS_RELOADING(UNIT(s)->manager) &&
!unit_has_name(UNIT(s), SPECIAL_INIT_SCOPE)) {
log_unit_error(UNIT(s), "Scope has no PIDs. Refusing.");
return -ENOENT;
}
return 0;
}
static int scope_verify(Scope *s) {
assert(s);
if (UNIT(s)->load_state != UNIT_LOADED)
return 0;
if (set_isempty(UNIT(s)->pids) &&
!manager_is_reloading_or_reexecuting(UNIT(s)->manager) &&
!unit_has_name(UNIT(s), SPECIAL_INIT_SCOPE)) {
log_unit_error(UNIT(s), "Scope has no PIDs. Refusing.");
return -EINVAL;
}
return 0;
}
static int automount_start(Unit *u) {
Automount *a = AUTOMOUNT(u);
assert(a);
assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_FAILED);
if (path_is_mount_point(a->where, 0) > 0) {
log_unit_error(u, "Path %s is already a mount point, refusing start.", a->where);
return -EEXIST;
}
if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
return -ENOENT;
a->result = AUTOMOUNT_SUCCESS;
automount_enter_waiting(a);
return 1;
}
static int busname_peek_message(BusName *n) {
struct kdbus_cmd_recv cmd_recv = {
.size = sizeof(cmd_recv),
.flags = KDBUS_RECV_PEEK,
};
struct kdbus_cmd_free cmd_free = {
.size = sizeof(cmd_free),
};
const char *comm = NULL;
struct kdbus_item *d;
struct kdbus_msg *k;
size_t start, ps, sz, delta;
void *p = NULL;
pid_t pid = 0;
int r;
/* Generate a friendly debug log message about which process
* caused triggering of this bus name. This simply peeks the
* metadata of the first queued message and logs it. */
assert(n);
/* Let's shortcut things a bit, if debug logging is turned off
* anyway. */
if (log_get_max_level() < LOG_DEBUG)
return 0;
r = ioctl(n->starter_fd, KDBUS_CMD_RECV, &cmd_recv);
if (r < 0) {
if (errno == EINTR || errno == EAGAIN)
return 0;
log_unit_error(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
return -errno;
}
/* We map as late as possible, and unmap imemdiately after
* use. On 32bit address space is scarce and we want to be
* able to handle a lot of activator connections at the same
* time, and hence shouldn't keep the mmap()s around for
* longer than necessary. */
ps = page_size();
start = (cmd_recv.msg.offset / ps) * ps;
delta = cmd_recv.msg.offset - start;
sz = PAGE_ALIGN(delta + cmd_recv.msg.msg_size);
p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
if (p == MAP_FAILED) {
log_unit_error(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
r = -errno;
goto finish;
}
k = (struct kdbus_msg *) ((uint8_t *) p + delta);
KDBUS_ITEM_FOREACH(d, k, items) {
switch (d->type) {
case KDBUS_ITEM_PIDS:
pid = d->pids.pid;
break;
case KDBUS_ITEM_PID_COMM:
comm = d->str;
break;
}
}
if (pid > 0)
log_unit_debug(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
r = 0;
finish:
if (p)
(void) munmap(p, sz);
cmd_free.offset = cmd_recv.msg.offset;
if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m");
return r;
}
static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
BusName *n = userdata;
assert(n);
assert(fd >= 0);
if (n->state != BUSNAME_LISTENING)
return 0;
log_unit_debug(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
if (revents != EPOLLIN) {
log_unit_error(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
UNIT(n)->id, revents);
goto fail;
}
busname_peek_message(n);
busname_enter_running(n);
return 0;
fail:
busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
return 0;
}
static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
BusName *n = BUSNAME(u);
BusNameResult f;
assert(n);
assert(pid >= 0);
if (pid != n->control_pid)
return;
n->control_pid = 0;
if (is_clean_exit(code, status, NULL))
f = BUSNAME_SUCCESS;
else if (code == CLD_EXITED)
f = BUSNAME_FAILURE_EXIT_CODE;
else if (code == CLD_KILLED)
f = BUSNAME_FAILURE_SIGNAL;
else if (code == CLD_DUMPED)
f = BUSNAME_FAILURE_CORE_DUMP;
else
assert_not_reached("Unknown sigchld code");
log_unit_full(u->id,
f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
"%s control process exited, code=%s status=%i",
u->id, sigchld_code_to_string(code), status);
if (f != BUSNAME_SUCCESS)
n->result = f;
switch (n->state) {
case BUSNAME_MAKING:
if (f == BUSNAME_SUCCESS)
busname_enter_listening(n);
else
busname_enter_signal(n, BUSNAME_SIGTERM, f);
break;
case BUSNAME_SIGTERM:
case BUSNAME_SIGKILL:
busname_enter_dead(n, f);
break;
default:
assert_not_reached("Uh, control process died at wrong time.");
}
/* Notify clients about changed exit status */
unit_add_to_dbus_queue(u);
}
static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
union autofs_v5_packet_union packet;
Automount *a = AUTOMOUNT(userdata);
struct stat st;
Unit *trigger;
int r;
assert(a);
assert(fd == a->pipe_fd);
if (events != EPOLLIN) {
log_unit_error(UNIT(a), "Got invalid poll event %"PRIu32" on pipe (fd=%d)", events, fd);
goto fail;
}
r = loop_read_exact(a->pipe_fd, &packet, sizeof(packet), true);
if (r < 0) {
log_unit_error_errno(UNIT(a), r, "Invalid read from pipe: %m");
goto fail;
}
switch (packet.hdr.type) {
case autofs_ptype_missing_direct:
if (packet.v5_packet.pid > 0) {
_cleanup_free_ char *p = NULL;
get_process_comm(packet.v5_packet.pid, &p);
log_unit_info(UNIT(a), "Got automount request for %s, triggered by %"PRIu32" (%s)", a->where, packet.v5_packet.pid, strna(p));
} else
log_unit_debug(UNIT(a), "Got direct mount request on %s", a->where);
r = set_ensure_allocated(&a->tokens, NULL);
if (r < 0) {
log_unit_error(UNIT(a), "Failed to allocate token set.");
goto fail;
}
r = set_put(a->tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));
if (r < 0) {
log_unit_error_errno(UNIT(a), r, "Failed to remember token: %m");
goto fail;
}
automount_enter_runnning(a);
break;
case autofs_ptype_expire_direct:
log_unit_debug(UNIT(a), "Got direct umount request on %s", a->where);
automount_stop_expire(a);
r = set_ensure_allocated(&a->expire_tokens, NULL);
if (r < 0) {
log_unit_error(UNIT(a), "Failed to allocate token set.");
goto fail;
}
r = set_put(a->expire_tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));
if (r < 0) {
log_unit_error_errno(UNIT(a), r, "Failed to remember token: %m");
goto fail;
}
/* Before we do anything, let's see if somebody is playing games with us? */
if (lstat(a->where, &st) < 0) {
log_unit_warning_errno(UNIT(a), errno, "Failed to stat automount point: %m");
goto fail;
}
if (!S_ISDIR(st.st_mode) || st.st_dev == a->dev_id) {
log_unit_info(UNIT(a), "Automount point already unmounted?");
automount_send_ready(a, a->expire_tokens, 0);
break;
}
trigger = UNIT_TRIGGER(UNIT(a));
if (!trigger) {
log_unit_error(UNIT(a), "Unit to trigger vanished.");
goto fail;
}
r = manager_add_job(UNIT(a)->manager, JOB_STOP, trigger, JOB_REPLACE, &error, NULL);
if (r < 0) {
log_unit_warning(UNIT(a), "Failed to queue umount startup job: %s", bus_error_message(&error, r));
goto fail;
}
break;
default:
log_unit_error(UNIT(a), "Received unknown automount request %i", packet.hdr.type);
break;
}
return 0;
fail:
automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
return 0;
}