1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
9 Job* job_new(Manager *m, JobType type, Name *name) {
13 assert(type < _JOB_TYPE_MAX);
16 if (!(j = new0(Job, 1)))
20 j->id = m->current_job_id++;
24 /* We don't link it here, that's what job_dependency() is for */
29 void job_free(Job *j) {
32 /* Detach from next 'bigger' objects */
34 if (j->name->meta.job == j)
35 j->name->meta.job = NULL;
37 hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
41 /* Detach from next 'smaller' objects */
42 manager_transaction_unlink_job(j->manager, j);
47 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters) {
52 /* Adds a new job link, which encodes that the 'subject' job
53 * needs the 'object' job in some way. If 'subject' is NULL
54 * this means the 'anchor' job (i.e. the one the user
55 * explcitily asked for) is the requester. */
57 if (!(l = new0(JobDependency, 1)))
65 l->subject_next = subject->subject_list;
66 subject->subject_list = l;
68 l->subject_next = object->manager->transaction_anchor;
69 object->manager->transaction_anchor = l;
73 l->subject_next->subject_prev = l;
74 l->subject_prev = NULL;
76 if ((l->object_next = object->object_list))
77 l->object_next->object_prev = l;
78 l->object_prev = NULL;
79 object->object_list = l;
84 void job_dependency_free(JobDependency *l) {
88 l->subject_prev->subject_next = l->subject_next;
90 l->subject->subject_list = l->subject_next;
92 l->object->manager->transaction_anchor = l->subject_next;
95 l->subject_next->subject_prev = l->subject_prev;
98 l->object_prev->object_next = l->object_next;
100 l->object->object_list = l->object_next;
103 l->object_next->object_prev = l->object_prev;
108 void job_dependency_delete(Job *subject, Job *object, bool *matters) {
113 for (l = object->object_list; l; l = l->object_next) {
114 assert(l->object == object);
116 if (l->subject == subject)
127 *matters = l->matters;
129 job_dependency_free(l);
132 const char* job_type_to_string(JobType t) {
134 static const char* const job_type_table[_JOB_TYPE_MAX] = {
135 [JOB_START] = "start",
136 [JOB_VERIFY_ACTIVE] = "verify-active",
138 [JOB_RELOAD] = "reload",
139 [JOB_RELOAD_OR_START] = "reload-or-start",
140 [JOB_RESTART] = "restart",
141 [JOB_TRY_RESTART] = "try-restart",
144 if (t < 0 || t >= _JOB_TYPE_MAX)
147 return job_type_table[t];
150 void job_dump(Job *j, FILE*f, const char *prefix) {
152 static const char* const job_state_table[_JOB_STATE_MAX] = {
153 [JOB_WAITING] = "waiting",
154 [JOB_RUNNING] = "running"
162 "%s\tAction: %s → %s\n"
166 prefix, name_id(j->name), job_type_to_string(j->type),
167 prefix, job_state_table[j->state],
168 prefix, yes_no(j->forced));
171 bool job_is_anchor(Job *j) {
176 for (l = j->object_list; l; l = l->object_next)
183 static bool types_match(JobType a, JobType b, JobType c, JobType d) {
185 (a == c && b == d) ||
189 int job_type_merge(JobType *a, JobType b) {
193 /* Merging is associative! a merged with b merged with c is
194 * the same as a merged with c merged with b. */
196 /* Mergeability is transitive! if a can be merged with b and b
197 * with c then a also with c */
199 /* Also, if a merged with b cannot be merged with c, then
200 * either a or b cannot be merged with c either */
202 if (types_match(*a, b, JOB_START, JOB_VERIFY_ACTIVE))
204 else if (types_match(*a, b, JOB_START, JOB_RELOAD) ||
205 types_match(*a, b, JOB_START, JOB_RELOAD_OR_START) ||
206 types_match(*a, b, JOB_VERIFY_ACTIVE, JOB_RELOAD_OR_START) ||
207 types_match(*a, b, JOB_RELOAD, JOB_RELOAD_OR_START))
208 *a = JOB_RELOAD_OR_START;
209 else if (types_match(*a, b, JOB_START, JOB_RESTART) ||
210 types_match(*a, b, JOB_START, JOB_TRY_RESTART) ||
211 types_match(*a, b, JOB_VERIFY_ACTIVE, JOB_RESTART) ||
212 types_match(*a, b, JOB_RELOAD, JOB_RESTART) ||
213 types_match(*a, b, JOB_RELOAD_OR_START, JOB_RESTART) ||
214 types_match(*a, b, JOB_RELOAD_OR_START, JOB_TRY_RESTART) ||
215 types_match(*a, b, JOB_RESTART, JOB_TRY_RESTART))
217 else if (types_match(*a, b, JOB_VERIFY_ACTIVE, JOB_RELOAD))
219 else if (types_match(*a, b, JOB_VERIFY_ACTIVE, JOB_TRY_RESTART) ||
220 types_match(*a, b, JOB_RELOAD, JOB_TRY_RESTART))
221 *a = JOB_TRY_RESTART;
228 bool job_type_is_mergeable(JobType a, JobType b) {
229 return job_type_merge(&a, b) >= 0;
232 bool job_type_is_superset(JobType a, JobType b) {
234 /* Checks whether operation a is a "superset" of b in its
242 return b == JOB_VERIFY_ACTIVE;
246 b == JOB_VERIFY_ACTIVE;
248 case JOB_RELOAD_OR_START:
252 b == JOB_VERIFY_ACTIVE;
257 b == JOB_VERIFY_ACTIVE ||
259 b == JOB_RELOAD_OR_START ||
260 b == JOB_TRY_RESTART;
262 case JOB_TRY_RESTART:
264 b == JOB_VERIFY_ACTIVE ||
272 bool job_type_is_conflicting(JobType a, JobType b) {
273 assert(a >= 0 && a < _JOB_TYPE_MAX);
274 assert(b >= 0 && b < _JOB_TYPE_MAX);
276 return (a == JOB_STOP) != (b == JOB_STOP);
279 bool job_type_is_applicable(JobType j, NameType n) {
280 assert(j >= 0 && j < _JOB_TYPE_MAX);
281 assert(n >= 0 && n < _NAME_TYPE_MAX);
284 case JOB_VERIFY_ACTIVE:
290 case JOB_TRY_RESTART:
291 return name_type_can_start(n);
294 return name_type_can_reload(n);
296 case JOB_RELOAD_OR_START:
297 return name_type_can_reload(n) && name_type_can_start(n);
300 assert_not_reached("Invalid job type");
304 bool job_is_runnable(Job *j) {
311 /* Checks whether there is any job running for the names this
312 * job needs to be running after (in the case of a 'positive'
313 * job type) or before (in the case of a 'negative' job type
316 if (j->type == JOB_START ||
317 j->type == JOB_VERIFY_ACTIVE ||
318 j->type == JOB_RELOAD ||
319 j->type == JOB_RELOAD_OR_START) {
321 /* Immediate result is that the job is or might be
322 * started. In this case lets wait for the
323 * dependencies, regardless whether they are
324 * starting or stopping something. */
326 SET_FOREACH(other, j->name->meta.dependencies[NAME_AFTER], state)
331 /* Also, if something else is being stopped and we should
332 * change state after it, then lets wait. */
334 SET_FOREACH(other, j->name->meta.dependencies[NAME_BEFORE], state)
335 if (other->meta.job &&
336 (other->meta.job->type == JOB_STOP ||
337 other->meta.job->type == JOB_RESTART ||
338 other->meta.job->type == JOB_TRY_RESTART))
341 /* This means that for a service a and a service b where b
342 * shall be started after a:
344 * start a + start b → 1st step start a, 2nd step start b
345 * start a + stop b → 1st step stop b, 2nd step start a
346 * stop a + start b → 1st step stop a, 2nd step start b
347 * stop a + stop b → 1st step stop b, 2nd step stop a
349 * This has the side effect that restarts are properly
350 * synchronized too. */
355 int job_run_and_invalidate(Job *j) {
359 if (!job_is_runnable(j))
362 if (j->state != JOB_WAITING)
368 r = name_start(j->name);
373 case JOB_VERIFY_ACTIVE: {
374 NameActiveState t = name_active_state(j->name);
375 if (NAME_IS_ACTIVE_OR_RELOADING(t))
377 else if (t == NAME_ACTIVATING)
385 r = name_stop(j->name);
389 r = name_reload(j->name);
392 case JOB_RELOAD_OR_START:
393 if (name_active_state(j->name) == NAME_ACTIVE)
394 r = name_reload(j->name);
396 r = name_start(j->name);
400 NameActiveState t = name_active_state(j->name);
401 if (t == NAME_INACTIVE || t == NAME_ACTIVATING) {
403 r = name_start(j->name);
405 r = name_stop(j->name);
409 case JOB_TRY_RESTART: {
410 NameActiveState t = name_active_state(j->name);
411 if (t == NAME_INACTIVE || t == NAME_DEACTIVATING)
413 else if (t == NAME_ACTIVATING) {
415 r = name_start(j->name);
417 r = name_stop(j->name);
426 j->state = JOB_RUNNING;
427 else if (r == -EALREADY)
428 r = job_finish_and_invalidate(j, true);
429 else if (r != -EAGAIN)
430 r = job_finish_and_invalidate(j, false);
435 int job_finish_and_invalidate(Job *j, bool success) {
443 if (success && (j->type == JOB_RESTART || j->type == JOB_TRY_RESTART)) {
444 j->state = JOB_RUNNING;
446 return job_run_and_invalidate(j);
453 /* Fail depending jobs on failure */
456 if (t == JOB_START ||
457 t == JOB_VERIFY_ACTIVE ||
458 t == JOB_RELOAD_OR_START) {
460 SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], state)
461 if (other->meta.job &&
462 (other->meta.type == JOB_START ||
463 other->meta.type == JOB_VERIFY_ACTIVE ||
464 other->meta.type == JOB_RELOAD_OR_START))
465 job_finish_and_invalidate(other->meta.job, false);
467 SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRED_BY], state)
468 if (other->meta.job &&
469 !other->meta.job->forced &&
470 (other->meta.type == JOB_START ||
471 other->meta.type == JOB_VERIFY_ACTIVE ||
472 other->meta.type == JOB_RELOAD_OR_START))
473 job_finish_and_invalidate(other->meta.job, false);
475 } else if (t == JOB_STOP) {
477 SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
478 if (other->meta.job &&
480 t == JOB_VERIFY_ACTIVE ||
481 t == JOB_RELOAD_OR_START))
482 job_finish_and_invalidate(other->meta.job, false);
486 /* Try to start the next jobs that can be started */
487 SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state)
489 job_run_and_invalidate(other->meta.job);
490 SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
492 job_run_and_invalidate(other->meta.job);