X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fjob.h;h=45d04874516dd0aa54d94c54620cd563fc0e1b1f;hp=0110126ce9f43f872f0d79d9bd71d73e29e82850;hb=37d3ab1b7e114f0fb6dfb2e7273569b42794b76a;hpb=05d576f1f77699ea5c2e5ed0e04451b14dfc45a0 diff --git a/src/core/job.h b/src/core/job.h index 0110126ce..45d048745 100644 --- a/src/core/job.h +++ b/src/core/job.h @@ -1,7 +1,6 @@ /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ -#ifndef foojobhfoo -#define foojobhfoo +#pragma once /*** This file is part of systemd. @@ -28,16 +27,12 @@ typedef struct Job Job; typedef struct JobDependency JobDependency; +typedef struct JobBusClient JobBusClient; typedef enum JobType JobType; typedef enum JobState JobState; typedef enum JobMode JobMode; typedef enum JobResult JobResult; -#include "manager.h" -#include "unit.h" -#include "hashmap.h" -#include "list.h" - /* Be careful when changing the job types! Adjust job_merging_table[] accordingly! */ enum JobType { JOB_START, /* if a unit does not support being started, we'll just wait until it becomes active */ @@ -45,14 +40,34 @@ enum JobType { JOB_STOP, - JOB_RELOAD, /* if running reload */ - JOB_RELOAD_OR_START, /* if running reload, if not running start */ + JOB_RELOAD, /* if running, reload */ /* Note that restarts are first treated like JOB_STOP, but * then instead of finishing are patched to become * JOB_START. */ - JOB_RESTART, /* if running stop, then start unconditionally */ - JOB_TRY_RESTART, /* if running stop and then start */ + JOB_RESTART, /* If running, stop. Then start unconditionally. */ + + _JOB_TYPE_MAX_MERGING, + + /* JOB_NOP can enter into a transaction, but as it won't pull in + * any dependencies, it won't have to merge with anything. + * job_install() avoids the problem of merging JOB_NOP too (it's + * special-cased, only merges with other JOB_NOPs). */ + JOB_NOP = _JOB_TYPE_MAX_MERGING, /* do nothing */ + + _JOB_TYPE_MAX_IN_TRANSACTION, + + /* JOB_TRY_RESTART can never appear in a transaction, because + * it always collapses into JOB_RESTART or JOB_NOP before entering. + * Thus we never need to merge it with anything. */ + JOB_TRY_RESTART = _JOB_TYPE_MAX_IN_TRANSACTION, /* if running, stop and then start */ + + /* JOB_RELOAD_OR_START won't enter into a transaction and cannot result + * from transaction merging (there's no way for JOB_RELOAD and + * JOB_START to meet in one transaction). It can result from a merge + * during job installation, but then it will immediately collapse into + * one of the two simpler types. */ + JOB_RELOAD_OR_START, /* if running, reload, otherwise start */ _JOB_TYPE_MAX, _JOB_TYPE_INVALID = -1 @@ -68,6 +83,7 @@ enum JobState { enum JobMode { JOB_FAIL, /* Fail if a conflicting job is already queued */ JOB_REPLACE, /* Replace an existing conflicting job */ + JOB_REPLACE_IRREVERSIBLY, /* Like JOB_REPLACE + produce irreversible jobs */ JOB_ISOLATE, /* Start a unit, and stop all others */ JOB_IGNORE_DEPENDENCIES, /* Ignore both requirement and ordering dependencies */ JOB_IGNORE_REQUIREMENTS, /* Ignore requirement dependencies */ @@ -76,16 +92,21 @@ enum JobMode { }; enum JobResult { - JOB_DONE, - JOB_CANCELED, - JOB_TIMEOUT, - JOB_FAILED, - JOB_DEPENDENCY, - JOB_SKIPPED, + JOB_DONE, /* Job completed successfully */ + JOB_CANCELED, /* Job canceled by a conflicting job installation or by explicit cancel request */ + JOB_TIMEOUT, /* JobTimeout elapsed */ + JOB_FAILED, /* Job failed */ + JOB_DEPENDENCY, /* A required dependency job did not result in JOB_DONE */ + JOB_SKIPPED, /* JOB_RELOAD of inactive unit; negative result of JOB_VERIFY_ACTIVE */ _JOB_RESULT_MAX, _JOB_RESULT_INVALID = -1 }; +#include "manager.h" +#include "unit.h" +#include "hashmap.h" +#include "list.h" + struct JobDependency { /* Encodes that the 'subject' job needs the 'object' job in * some way. This structure is used only while building a transaction. */ @@ -99,6 +120,13 @@ struct JobDependency { bool conflicts; }; +struct JobBusClient { + LIST_FIELDS(JobBusClient, client); + /* Note that this bus object is not ref counted here. */ + DBusConnection *bus; + char name[0]; +}; + struct Job { Manager *manager; Unit *unit; @@ -121,9 +149,8 @@ struct Job { Watch timer_watch; - /* Note that this bus object is not ref counted here. */ - DBusConnection *bus; - char *bus_client; + /* There can be more than one client, because of job merging. */ + LIST_HEAD(JobBusClient, bus_client_list); JobResult result; @@ -134,13 +161,22 @@ struct Job { bool in_dbus_queue:1; bool sent_dbus_new_signal:1; bool ignore_order:1; + bool forgot_bus_clients:1; + bool irreversible:1; }; +JobBusClient* job_bus_client_new(DBusConnection *connection, const char *name); + Job* job_new(Unit *unit, JobType type); +Job* job_new_raw(Unit *unit); void job_free(Job *job); -void job_install(Job *j); +Job* job_install(Job *j); +int job_install_deserialized(Job *j); void job_uninstall(Job *j); void job_dump(Job *j, FILE*f, const char *prefix); +int job_serialize(Job *j, FILE *f, FDSet *fds); +int job_deserialize(Job *j, FILE *f, FDSet *fds); +int job_coldplug(Job *j); JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts); void job_dependency_free(JobDependency *l); @@ -149,14 +185,6 @@ int job_merge(Job *j, Job *other); JobType job_type_lookup_merge(JobType a, JobType b); -static inline int job_type_merge(JobType *a, JobType b) { - JobType t = job_type_lookup_merge(*a, b); - if (t < 0) - return -EEXIST; - *a = t; - return 0; -} - static inline bool job_type_is_mergeable(JobType a, JobType b) { return job_type_lookup_merge(a, b) >= 0; } @@ -172,6 +200,12 @@ static inline bool job_type_is_superset(JobType a, JobType b) { bool job_type_is_redundant(JobType a, UnitActiveState b); +/* Collapses a state-dependent job type into a simpler type by observing + * the state of the unit which it is going to be applied to. */ +void job_type_collapse(JobType *t, Unit *u); + +int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u); + bool job_is_runnable(Job *j); void job_add_to_run_queue(Job *j); @@ -181,10 +215,12 @@ int job_start_timer(Job *j); void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w); int job_run_and_invalidate(Job *j); -int job_finish_and_invalidate(Job *j, JobResult result); +int job_finish_and_invalidate(Job *j, JobResult result, bool recursive); char *job_dbus_path(Job *j); +void job_shutdown_magic(Job *j); + const char* job_type_to_string(JobType t); JobType job_type_from_string(const char *s); @@ -196,5 +232,3 @@ JobMode job_mode_from_string(const char *s); const char* job_result_to_string(JobResult t); JobResult job_result_from_string(const char *s); - -#endif