#include <assert.h>
#include <errno.h>
#include <string.h>
+#include <sys/epoll.h>
+#include <signal.h>
+#include <sys/signalfd.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/poll.h>
#include "manager.h"
#include "hashmap.h"
Manager* manager_new(void) {
Manager *m;
+ sigset_t mask;
+ struct epoll_event ev;
if (!(m = new0(Manager, 1)))
return NULL;
+ m->signal_fd = m->epoll_fd = -1;
+
if (!(m->names = hashmap_new(string_hash_func, string_compare_func)))
goto fail;
if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
goto fail;
+ if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
+ goto fail;
+
+ if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+ goto fail;
+
+ assert_se(sigemptyset(&mask) == 0);
+ assert_se(sigaddset(&mask, SIGCHLD) == 0);
+ assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
+
+ if ((m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
+ goto fail;
+
+ zero(ev);
+ ev.events = EPOLLIN;
+ ev.data.fd = m->signal_fd;
+
+ if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_fd, &ev) < 0)
+ goto fail;
+
return m;
fail:
hashmap_free(m->names);
hashmap_free(m->jobs);
hashmap_free(m->transaction_jobs);
+ hashmap_free(m->watch_pids);
+
+ if (m->epoll_fd >= 0)
+ close_nointr(m->epoll_fd);
+ if (m->signal_fd >= 0)
+ close_nointr(m->signal_fd);
free(m);
}
j->type = t;
j->state = JOB_WAITING;
+ j->forced = j->forced || other->forced;
j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
transaction_delete_job(m, other);
}
-static int delete_one_unmergable_job(Manager *m, Job *j) {
+static int delete_one_unmergeable_job(Manager *m, Job *j) {
Job *k;
assert(j);
Job *d;
/* Is this one mergeable? Then skip it */
- if (job_type_mergeable(j->type, k->type))
+ if (job_type_is_mergeable(j->type, k->type))
continue;
/* Ok, we found two that conflict, let's see if we can
return -ENOEXEC;
/* Ok, we can drop one, so let's do so. */
- log_debug("Try to fix job merging by deleting job %s", name_id(d->name));
+ log_debug("Try to fix job merging by deleting job %s/%s", name_id(d->name), job_type_to_string(d->type));
transaction_delete_job(m, d);
return 0;
}
* action. Let's see if we can get rid of one
* of them */
- if ((r = delete_one_unmergable_job(m, j)) >= 0)
+ if ((r = delete_one_unmergeable_job(m, j)) >= 0)
/* Ok, we managed to drop one, now
* let's ask our callers to call us
* again after garbage collecting */
for (k = j->transaction_next; k; k = k->transaction_next)
assert_se(job_type_merge(&t, k->type) == 0);
- /* If an active job is mergable, merge it too */
+ /* If an active job is mergeable, merge it too */
if (j->name->meta.job)
job_type_merge(&t, j->name->meta.job->type); /* Might fail. Which is OK */
!name_matters_to_anchor(k->name, k)) {
/* Ok, we can drop this one, so let's
* do so. */
- log_debug("Breaking order cycle by deleting job %s", name_id(k->name));
+ log_debug("Breaking order cycle by deleting job %s/%s", name_id(k->name), job_type_to_string(k->type));
transaction_delete_name(m, k->name);
return -EAGAIN;
}
if (j->object_list)
continue;
- log_debug("Garbage collecting job %s", name_id(j->name));
-
+ log_debug("Garbage collecting job %s/%s", name_id(j->name), job_type_to_string(j->type));
transaction_delete_job(m, j);
again = true;
break;
/* Would this stop a running service?
* Would this change an existing job?
* If so, let's drop this entry */
- if ((j->type != JOB_STOP || name_is_dead(j->name)) &&
+ if ((j->type != JOB_STOP || NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(j->name))) &&
(!j->name->meta.job || job_type_is_conflicting(j->type, j->name->meta.job->state)))
continue;
/* Ok, let's get rid of this */
+ log_debug("Deleting %s/%s to minimize impact", name_id(j->name), job_type_to_string(j->type));
transaction_delete_job(m, j);
again = true;
break;
}
for (;;) {
- /* Fifth step: let's drop unmergable entries if
+ /* Fifth step: let's drop unmergeable entries if
* necessary and possible, merge entries we can
* merge */
if ((r = transaction_merge_jobs(m)) >= 0)
transaction_collect_garbage(m);
/* Let's see if the resulting transaction still has
- * unmergable entries ... */
+ * unmergeable entries ... */
}
/* Seventh step: check whether we can actually apply this */
return r;
}
-static Job* transaction_add_one_job(Manager *m, JobType type, Name *name, bool *is_new) {
+static Job* transaction_add_one_job(Manager *m, JobType type, Name *name, bool force, bool *is_new) {
Job *j, *f;
int r;
j->generation = 0;
j->marker = NULL;
j->matters_to_anchor = false;
+ j->forced = force;
if (is_new)
*is_new = true;
job_dependency_free(j->object_list);
if (other) {
- log_debug("Deleting job %s as dependency of job %s", name_id(other->name), name_id(j->name));
+ log_debug("Deleting job %s/%s as dependency of job %s/%s",
+ name_id(other->name), job_type_to_string(other->type),
+ name_id(j->name), job_type_to_string(j->type));
transaction_delete_job(m, other);
}
}
assert(type < _JOB_TYPE_MAX);
assert(name);
- if (name->meta.state != NAME_LOADED)
+ if (name->meta.load_state != NAME_LOADED)
return -EINVAL;
+ if (!job_type_is_applicable(type, name->meta.type))
+ return -EBADR;
+
/* First add the job. */
- if (!(ret = transaction_add_one_job(m, type, name, &is_new)))
+ if (!(ret = transaction_add_one_job(m, type, name, force, &is_new)))
return -ENOMEM;
/* Then, add a link to the job. */
/* Finally, recursively add in all dependencies. */
if (type == JOB_START || type == JOB_RELOAD_OR_START) {
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRES], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
goto fail;
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUIRES], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !force, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
goto fail;
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_WANTS], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, force, NULL)) < 0 && r != -EBADR)
goto fail;
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUISITE], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_STARTED, dep, ret, true, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
goto fail;
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_SOFT_REQUISITE], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_STARTED, dep, ret, !force, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
goto fail;
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_CONFLICTS], state)
- if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
goto fail;
} else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
SET_FOREACH(dep, ret->name->meta.dependencies[NAME_REQUIRED_BY], state)
- if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, force, NULL)) < 0)
+ if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
goto fail;
}
while ((j = hashmap_first(m->jobs)))
job_free(j);
}
+
+void manager_run_jobs(Manager *m) {
+ Job *j;
+ void *state;
+ int r;
+
+ HASHMAP_FOREACH(j, m->jobs, state) {
+ r = job_run_and_invalidate(j);
+
+ /* FIXME... the list of jobs might have changed */
+ }
+}
+
+int manager_dispatch_sigchld(Manager *m) {
+ assert(m);
+
+ for (;;) {
+ siginfo_t si;
+ Name *n;
+
+ zero(si);
+ if (waitid(P_ALL, 0, &si, WNOHANG) < 0)
+ return -errno;
+
+ if (si.si_pid == 0)
+ break;
+
+ if (!(n = hashmap_remove(m->watch_pids, UINT32_TO_PTR(si.si_pid))))
+ continue;
+
+ NAME_VTABLE(n)->sigchld_event(n, si.si_pid, si.si_code, si.si_status);
+ }
+
+ return 0;
+}
+
+int manager_process_signal_fd(Manager *m) {
+ ssize_t n;
+ struct signalfd_siginfo sfsi;
+ bool sigchld = false;
+
+ assert(m);
+
+ for (;;) {
+ if ((n = read(m->signal_fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
+
+ if (n >= 0)
+ return -EIO;
+
+ if (errno == EAGAIN)
+ return 0;
+
+ return -errno;
+ }
+
+ if (sfsi.ssi_signo == SIGCHLD)
+ sigchld = true;
+ }
+
+ if (sigchld)
+ manager_dispatch_sigchld(m);
+
+ return 0;
+}
+
+int manager_loop(Manager *m) {
+ int r;
+ struct epoll_event events[32];
+
+ assert(m);
+
+ for (;;) {
+ int n, i;
+
+ if ((n = epoll_wait(m->epoll_fd, events, ELEMENTSOF(events), -1)) < 0) {
+
+ if (errno == -EINTR)
+ continue;
+
+ return -errno;
+ }
+
+ for (i = 0; i < n; i++) {
+
+ if (events[i].data.fd == m->signal_fd) {
+
+ /* An incoming signal? */
+ if (events[i].events != POLLIN)
+ return -EINVAL;
+
+ if ((r = manager_process_signal_fd(m)) < 0)
+ return -r;
+ } else {
+ Name *n;
+
+ /* Some other fd event, to be dispatched to the names */
+ assert_se(n = events[i].data.ptr);
+ NAME_VTABLE(n)->fd_event(n, events[i].data.fd, events[i].events);
+ }
+ }
+ }
+}