X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fjob.h;h=d967b68a3fd84cbf16c7d4ff7544ddb6965f508e;hp=9da7e84a7902dde372c8b997d8dffcd7c774ccc2;hb=615938651d3a4fd9253b08da00db22d451a8cef8;hpb=39a18c60d07319ebfcfd476556729c2cadd616d6 diff --git a/src/core/job.h b/src/core/job.h index 9da7e84a7..d967b68a3 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,17 +27,11 @@ 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 */ @@ -46,14 +39,36 @@ 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 and it uses the special 'nop_job' slot in Unit, + * it won't have to merge with anything (except possibly into another + * JOB_NOP, previously installed). JOB_NOP is special-cased in + * job_type_is_*() functions so that the transaction can be + * activated. */ + 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 @@ -69,7 +84,9 @@ 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_FLUSH, /* Flush out all other queued jobs when queing this one */ JOB_IGNORE_DEPENDENCIES, /* Ignore both requirement and ordering dependencies */ JOB_IGNORE_REQUIREMENTS, /* Ignore requirement dependencies */ _JOB_MODE_MAX, @@ -77,16 +94,25 @@ 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, /* Job timeout elapsed */ + JOB_FAILED, /* Job failed */ + JOB_DEPENDENCY, /* A required dependency job did not result in JOB_DONE */ + JOB_SKIPPED, /* Negative result of JOB_VERIFY_ACTIVE */ + JOB_INVALID, /* JOB_RELOAD of inactive unit */ + JOB_ASSERT, /* Couldn't start a unit, because an assert didn't hold */ + JOB_UNSUPPORTED, /* Couldn't start a unit, because the unit type is not supported on the system */ _JOB_RESULT_MAX, _JOB_RESULT_INVALID = -1 }; +#include "sd-event.h" +#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. */ @@ -100,13 +126,6 @@ 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; @@ -127,10 +146,18 @@ struct Job { JobType type; JobState state; - Watch timer_watch; + sd_event_source *timer_event_source; + usec_t begin_usec; - /* There can be more than one client, because of job merging. */ - LIST_HEAD(JobBusClient, bus_client_list); + /* + * This tracks where to send signals, and also which clients + * are allowed to call DBus methods on the job (other than + * root). + * + * There can be more than one client, because of job merging. + */ + sd_bus_track *clients; + char **deserialized_clients; JobResult result; @@ -141,16 +168,14 @@ 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); Job* job_install(Job *j); -void job_install_deserialized(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); @@ -162,54 +187,55 @@ void job_dependency_free(JobDependency *l); 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; -} +JobType job_type_lookup_merge(JobType a, JobType b) _pure_; -static inline bool job_type_is_mergeable(JobType a, JobType b) { +_pure_ static inline bool job_type_is_mergeable(JobType a, JobType b) { return job_type_lookup_merge(a, b) >= 0; } -static inline bool job_type_is_conflicting(JobType a, JobType b) { - return !job_type_is_mergeable(a, b); +_pure_ static inline bool job_type_is_conflicting(JobType a, JobType b) { + return a != JOB_NOP && b != JOB_NOP && !job_type_is_mergeable(a, b); } -static inline bool job_type_is_superset(JobType a, JobType b) { +_pure_ static inline bool job_type_is_superset(JobType a, JobType b) { /* Checks whether operation a is a "superset" of b in its actions */ + if (b == JOB_NOP) + return true; + if (a == JOB_NOP) + return false; return a == job_type_lookup_merge(a, b); } -bool job_type_is_redundant(JobType a, UnitActiveState b); +bool job_type_is_redundant(JobType a, UnitActiveState b) _pure_; -bool job_is_runnable(Job *j); +/* 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); void job_add_to_run_queue(Job *j); void job_add_to_dbus_queue(Job *j); 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); -const char* job_type_to_string(JobType t); -JobType job_type_from_string(const char *s); +void job_shutdown_magic(Job *j); + +const char* job_type_to_string(JobType t) _const_; +JobType job_type_from_string(const char *s) _pure_; -const char* job_state_to_string(JobState t); -JobState job_state_from_string(const char *s); +const char* job_state_to_string(JobState t) _const_; +JobState job_state_from_string(const char *s) _pure_; -const char* job_mode_to_string(JobMode t); -JobMode job_mode_from_string(const char *s); +const char* job_mode_to_string(JobMode t) _const_; +JobMode job_mode_from_string(const char *s) _pure_; -const char* job_result_to_string(JobResult t); -JobResult job_result_from_string(const char *s); +const char* job_result_to_string(JobResult t) _const_; +JobResult job_result_from_string(const char *s) _pure_; -#endif +int job_get_timeout(Job *j, uint64_t *timeout) _pure_;