#include "dbus-unit.h"
#include "dbus-job.h"
+/* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
+#define GC_QUEUE_ENTRIES_MAX 16
+
+/* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
+#define GC_QUEUE_USEC_MAX (5*USEC_PER_SEC)
+
static int enable_special_signals(Manager *m) {
char fd;
return n;
}
+static void unit_gc_sweep(Unit *u, int gc_marker) {
+ Iterator i;
+ Unit *other;
+
+ assert(u);
+
+ if (u->meta.gc_marker == gc_marker ||
+ u->meta.gc_marker == -gc_marker)
+ return;
+
+ if (u->meta.in_cleanup_queue)
+ goto bad;
+
+ if (unit_check_gc(u))
+ goto good;
+
+ SET_FOREACH(other, u->meta.dependencies[UNIT_REFERENCED_BY], i) {
+ unit_gc_sweep(other, gc_marker);
+
+ if (other->meta.gc_marker == gc_marker)
+ goto good;
+ }
+
+bad:
+ /* So there is no reason to keep this unit around, hence let's get rid of it */
+ u->meta.gc_marker = -gc_marker;
+ return;
+
+good:
+ u->meta.gc_marker = gc_marker;
+}
+
+static unsigned manager_dispatch_gc_queue(Manager *m) {
+ Meta *meta;
+ unsigned n = 0;
+ int gc_marker;
+
+ assert(m);
+
+ if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
+ (m->gc_queue_timestamp <= 0 ||
+ (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
+ return 0;
+
+ log_debug("Running GC...");
+
+ gc_marker = ++m->gc_marker;
+
+ if (m->gc_marker < 0)
+ m->gc_marker = 1;
+
+ while ((meta = m->gc_queue)) {
+ assert(meta->in_gc_queue);
+
+ LIST_REMOVE(Meta, gc_queue, m->gc_queue, meta);
+ meta->in_gc_queue = false;
+
+ n++;
+
+ unit_gc_sweep(UNIT(meta), gc_marker);
+
+ if (meta->gc_marker == -gc_marker) {
+ log_debug("Collecting %s", meta->id);
+ unit_add_to_cleanup_queue(UNIT(meta));
+ }
+ }
+
+ m->n_in_gc_queue = 0;
+ m->gc_queue_timestamp = 0;
+
+ return n;
+}
+
static void manager_clear_jobs_and_units(Manager *m) {
Job *j;
Unit *u;
} while (again);
}
-static int transaction_is_destructive(Manager *m, JobMode mode) {
+static int transaction_is_destructive(Manager *m) {
Iterator i;
Job *j;
} while (again);
}
-static int transaction_apply(Manager *m, JobMode mode) {
+static int transaction_apply(Manager *m) {
Iterator i;
Job *j;
int r;
/* Ninth step: check whether we can actually apply this */
if (mode == JOB_FAIL)
- if ((r = transaction_is_destructive(m, mode)) < 0) {
+ if ((r = transaction_is_destructive(m)) < 0) {
log_debug("Requested transaction contradicts existing jobs: %s", strerror(-r));
goto rollback;
}
/* Tenth step: apply changes */
- if ((r = transaction_apply(m, mode)) < 0) {
+ if ((r = transaction_apply(m)) < 0) {
log_debug("Failed to apply transaction: %s", strerror(-r));
goto rollback;
}
return r;
}
+static int transaction_add_isolate_jobs(Manager *m) {
+ Iterator i;
+ Unit *u;
+ char *k;
+ int r;
+
+ assert(m);
+
+ HASHMAP_FOREACH_KEY(u, k, m->units, i) {
+
+ /* ignore aliases */
+ if (u->meta.id != k)
+ continue;
+
+ if (UNIT_VTABLE(u)->no_isolate)
+ continue;
+
+ /* No need to stop inactive jobs */
+ if (unit_active_state(u) == UNIT_INACTIVE)
+ continue;
+
+ /* Is there already something listed for this? */
+ if (hashmap_get(m->transaction_jobs, u))
+ continue;
+
+ if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, NULL)) < 0)
+ log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->meta.id, strerror(-r));
+ }
+
+ return 0;
+}
+
int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, Job **_ret) {
int r;
Job *ret;
assert(unit);
assert(mode < _JOB_MODE_MAX);
+ if (mode == JOB_ISOLATE && type != JOB_START)
+ return -EINVAL;
+
log_debug("Trying to enqueue job %s/%s", unit->meta.id, job_type_to_string(type));
if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, &ret)) < 0) {
return r;
}
+ if (mode == JOB_ISOLATE)
+ if ((r = transaction_add_isolate_jobs(m)) < 0) {
+ transaction_abort(m);
+ return r;
+ }
+
if ((r = transaction_activate(m, mode)) < 0)
return r;
if (manager_dispatch_cleanup_queue(m) > 0)
continue;
+ if (manager_dispatch_gc_queue(m) > 0)
+ continue;
+
if (manager_dispatch_load_queue(m) > 0)
continue;