X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=manager.c;h=7941d89a75f52c86dbf8ce729255e3cf1c36a400;hp=94ad680eb40aae645a5a603f398f9e0467bd867f;hb=83c60c9f0c7581b607dc5c0f84582978894e3d4a;hpb=1ffba6fe82d65f2a87b53a21c7927bca8176038c diff --git a/manager.c b/manager.c index 94ad680eb..7941d89a7 100644 --- a/manager.c +++ b/manager.c @@ -127,6 +127,7 @@ static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, Job 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; @@ -168,7 +169,7 @@ static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, Job 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); @@ -185,7 +186,7 @@ static int delete_one_unmergable_job(Manager *m, Job *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 @@ -198,7 +199,7 @@ static int delete_one_unmergable_job(Manager *m, Job *j) { 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; } @@ -228,7 +229,7 @@ static int transaction_merge_jobs(Manager *m) { * 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 */ @@ -244,9 +245,14 @@ static int transaction_merge_jobs(Manager *m) { JobType t = j->type; Job *k; + /* Merge all transactions */ for (k = j->transaction_next; k; k = k->transaction_next) assert_se(job_type_merge(&t, k->type) == 0); + /* 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 */ + while ((k = j->transaction_next)) { if (j->linked) { transaction_merge_and_delete_job(m, k, j, t); @@ -305,7 +311,7 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned !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; } @@ -380,8 +386,7 @@ static void transaction_collect_garbage(Manager *m) { 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; @@ -399,15 +404,62 @@ static int transaction_is_destructive(Manager *m, JobMode mode) { /* Checks whether applying this transaction means that * existing jobs would be replaced */ - HASHMAP_FOREACH(j, m->transaction_jobs, state) + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + + /* Assume merged */ + assert(!j->transaction_prev); + assert(!j->transaction_next); + if (j->name->meta.job && j->name->meta.job != j && !job_type_is_superset(j->type, j->name->meta.job->type)) return -EEXIST; + } return 0; } +static void transaction_minimize_impact(Manager *m) { + bool again; + assert(m); + + /* Drops all unnecessary jobs that reverse already active jobs + * or that stop a running service. */ + + do { + Job *j; + void *state; + + again = false; + + HASHMAP_FOREACH(j, m->transaction_jobs, state) { + for (; j; j = j->transaction_next) { + + /* If it matters, we shouldn't drop it */ + if (j->matters_to_anchor) + continue; + + /* 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_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; + } + + if (again) + break; + } + + } while (again); +} + static int transaction_apply(Manager *m, JobMode mode) { void *state; Job *j; @@ -416,6 +468,10 @@ static int transaction_apply(Manager *m, JobMode mode) { /* Moves the transaction jobs to the set of active jobs */ HASHMAP_FOREACH(j, m->transaction_jobs, state) { + /* Assume merged */ + assert(!j->transaction_prev); + assert(!j->transaction_next); + if (j->linked) continue; @@ -461,7 +517,6 @@ rollback: return r; } - static int transaction_activate(Manager *m, JobMode mode) { int r; unsigned generation = 1; @@ -474,12 +529,17 @@ static int transaction_activate(Manager *m, JobMode mode) { /* First step: figure out which jobs matter */ transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++); + /* Second step: Try not to stop any running services if + * we don't have to. Don't try to reverse running + * jobs if we don't have to. */ + transaction_minimize_impact(m); + for (;;) { - /* Second step: Let's remove unneeded jobs that might + /* Third step: Let's remove unneeded jobs that might * be lurking. */ transaction_collect_garbage(m); - /* Third step: verify order makes sense and correct + /* Fourth step: verify order makes sense and correct * cycles if necessary and possible */ if ((r = transaction_verify_order(m, &generation)) >= 0) break; @@ -492,7 +552,7 @@ static int transaction_activate(Manager *m, JobMode mode) { } for (;;) { - /* Fourth 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) @@ -501,20 +561,20 @@ static int transaction_activate(Manager *m, JobMode mode) { if (r != -EAGAIN) goto rollback; - /* Fifth step: an entry got dropped, let's garbage + /* Sixth step: an entry got dropped, let's garbage * collect its dependencies. */ transaction_collect_garbage(m); /* Let's see if the resulting transaction still has - * unmergable entries ... */ + * unmergeable entries ... */ } - /* Sith step: check whether we can actually apply this */ + /* Seventh step: check whether we can actually apply this */ if (mode == JOB_FAIL) if ((r = transaction_is_destructive(m, mode)) < 0) goto rollback; - /* Seventh step: apply changes */ + /* Eights step: apply changes */ if ((r = transaction_apply(m, mode)) < 0) goto rollback; @@ -528,7 +588,7 @@ rollback: 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; @@ -569,6 +629,7 @@ static Job* transaction_add_one_job(Manager *m, JobType type, Name *name, bool * j->generation = 0; j->marker = NULL; j->matters_to_anchor = false; + j->forced = force; if (is_new) *is_new = true; @@ -601,7 +662,9 @@ void manager_transaction_unlink_job(Manager *m, Job *j) { 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); } } @@ -618,11 +681,14 @@ static int transaction_add_job_and_dependencies(Manager *m, JobType type, Name * 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. */ @@ -633,28 +699,28 @@ static int transaction_add_job_and_dependencies(Manager *m, JobType type, Name * /* 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; } @@ -816,3 +882,13 @@ void manager_clear_jobs(Manager *m) { 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); + } +}