if (!s)
return -ENOMEM;
- if (!unit_name_is_valid(s)) {
+ if (!unit_name_is_valid(s, false)) {
r = -EINVAL;
goto fail;
}
set_free_free(u->meta.names);
- free(u->meta.instance);
+ condition_free_list(u->meta.conditions);
+ free(u->meta.instance);
free(u);
}
assert(other);
assert(d < _UNIT_DEPENDENCY_MAX);
+ /* Fix backwards pointers */
SET_FOREACH(back, other->meta.dependencies[d], i) {
UnitDependency k;
if (u->meta.description)
return u->meta.description;
- return u->meta.id;
+ return strna(u->meta.id);
}
void unit_dump(Unit *u, FILE *f, const char *prefix) {
if (u->meta.job_timeout > 0)
fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->meta.job_timeout));
+ condition_dump_list(u->meta.conditions, f, prefix);
+
for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
Unit *other;
return 0;
}
-static int unit_add_one_default_dependency(Unit *u, Unit *target) {
+int unit_add_default_target_dependency(Unit *u, Unit *target) {
assert(u);
assert(target);
if (target->meta.type != UNIT_TARGET)
return 0;
+ /* Only add the dependency if boths units are loaded, so that
+ * that loop check below is reliable */
+ if (u->meta.load_state != UNIT_LOADED ||
+ target->meta.load_state != UNIT_LOADED)
+ return 0;
+
/* Don't create loops */
if (set_get(target->meta.dependencies[UNIT_BEFORE], u))
return 0;
}
static int unit_add_default_dependencies(Unit *u) {
- Unit *other;
+ Unit *target;
Iterator i;
int r;
assert(u);
- SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY], i)
- if ((r = unit_add_one_default_dependency(u, other)) < 0)
+ SET_FOREACH(target, u->meta.dependencies[UNIT_REQUIRED_BY], i)
+ if ((r = unit_add_default_target_dependency(u, target)) < 0)
return r;
- SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
- if ((r = unit_add_one_default_dependency(u, other)) < 0)
+ SET_FOREACH(target, u->meta.dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
+ if ((r = unit_add_default_target_dependency(u, target)) < 0)
return r;
- SET_FOREACH(other, u->meta.dependencies[UNIT_WANTED_BY], i)
- if ((r = unit_add_one_default_dependency(u, other)) < 0)
+ SET_FOREACH(target, u->meta.dependencies[UNIT_WANTED_BY], i)
+ if ((r = unit_add_default_target_dependency(u, target)) < 0)
return r;
return 0;
if (!UNIT_VTABLE(u)->start)
return -EBADR;
+ /* If the conditions failed, don't do anything at all */
+ if (!condition_test_list(u->meta.conditions)) {
+ log_debug("Starting of %s requested but condition failed. Ignoring.", u->meta.id);
+ return -EALREADY;
+ }
+
/* We don't suppress calls to ->start() here when we are
* already starting, to allow this request to be used as a
* "hurry up" call, for example when the unit is in some "auto
return UNIT_VTABLE(u)->can_reload(u);
}
-static void unit_check_uneeded(Unit *u) {
+static void unit_check_unneeded(Unit *u) {
Iterator i;
Unit *other;
/* Garbage collect services that might not be needed anymore, if enabled */
SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES], i)
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
- unit_check_uneeded(other);
+ unit_check_unneeded(other);
SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
- unit_check_uneeded(other);
+ unit_check_unneeded(other);
SET_FOREACH(other, u->meta.dependencies[UNIT_WANTS], i)
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
- unit_check_uneeded(other);
+ unit_check_unneeded(other);
SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE], i)
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
- unit_check_uneeded(other);
+ unit_check_unneeded(other);
SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
- unit_check_uneeded(other);
+ unit_check_unneeded(other);
}
void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
if (u->meta.type == UNIT_SERVICE &&
!UNIT_IS_ACTIVE_OR_RELOADING(os)) {
/* Write audit record if we have just finished starting up */
- manager_send_unit_audit(u->meta.manager, u, AUDIT_SERVICE_START, 1);
+ manager_send_unit_audit(u->meta.manager, u, AUDIT_SERVICE_START, true);
u->meta.in_audit = true;
}
+ if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
+ manager_send_unit_plymouth(u->meta.manager, u);
+
} else {
if (unit_has_name(u, SPECIAL_SYSLOG_SERVICE))
/* Maybe we finished startup and are now ready for being
* stopped because unneeded? */
- unit_check_uneeded(u);
+ unit_check_unneeded(u);
unit_add_to_dbus_queue(u);
unit_add_to_gc_queue(u);
assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
assert(other);
+ u = unit_follow_merge(u);
+ other = unit_follow_merge(other);
+
/* We won't allow dependencies on ourselves. We will not
* consider them an error however. */
if (u == other)
return false;
}
+bool unit_pending_active(Unit *u) {
+ assert(u);
+
+ /* Returns true if the unit is inactive or going down */
+
+ if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
+ return true;
+
+ if (u->meta.job &&
+ (u->meta.job->type == JOB_START ||
+ u->meta.job->type == JOB_RELOAD_OR_START ||
+ u->meta.job->type == JOB_RESTART))
+ return true;
+
+ return false;
+}
+
+UnitType unit_name_to_type(const char *n) {
+ UnitType t;
+
+ assert(n);
+
+ for (t = 0; t < _UNIT_TYPE_MAX; t++)
+ if (endswith(n, unit_vtable[t]->suffix))
+ return t;
+
+ return _UNIT_TYPE_INVALID;
+}
+
+bool unit_name_is_valid(const char *n, bool template_ok) {
+ UnitType t;
+
+ t = unit_name_to_type(n);
+ if (t < 0 || t >= _UNIT_TYPE_MAX)
+ return false;
+
+ return unit_name_is_valid_no_type(n, template_ok);
+}
+
static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
[UNIT_STUB] = "stub",
[UNIT_LOADED] = "loaded",
[UNIT_ERROR] = "error",
- [UNIT_MERGED] = "merged"
+ [UNIT_MERGED] = "merged",
+ [UNIT_MASKED] = "masked"
};
DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
~ianmdlvl / elogind.git / blobdiff