src/job.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #ifndef foojobhfoo
   4 #define foojobhfoo
   5
   6 /***
   7   This file is part of systemd.
   8
   9   Copyright 2010 Lennart Poettering
  10
  11   systemd is free software; you can redistribute it and/or modify it
  12   under the terms of the GNU General Public License as published by
  13   the Free Software Foundation; either version 2 of the License, or
  14   (at your option) any later version.
  15
  16   systemd is distributed in the hope that it will be useful, but
  17   WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19   General Public License for more details.
  20
  21   You should have received a copy of the GNU General Public License
  22   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  23 ***/
  24
  25 #include <stdbool.h>
  26 #include <inttypes.h>
  27 #include <errno.h>
  28
  29 typedef struct Job Job;
  30 typedef struct JobDependency JobDependency;
  31 typedef enum JobType JobType;
  32 typedef enum JobState JobState;
  33 typedef enum JobMode JobMode;
  34 typedef enum JobResult JobResult;
  35
  36 #include "manager.h"
  37 #include "unit.h"
  38 #include "hashmap.h"
  39 #include "list.h"
  40
  41 /* Be careful when changing the job types! Adjust job_merging_table[] accordingly! */
  42 enum JobType {
  43         JOB_START,                  /* if a unit does not support being started, we'll just wait until it becomes active */
  44         JOB_VERIFY_ACTIVE,
  45
  46         JOB_STOP,
  47
  48         JOB_RELOAD,                 /* if running reload */
  49         JOB_RELOAD_OR_START,        /* if running reload, if not running start */
  50
  51         /* Note that restarts are first treated like JOB_STOP, but
  52          * then instead of finishing are patched to become
  53          * JOB_START. */
  54         JOB_RESTART,                /* if running stop, then start unconditionally */
  55         JOB_TRY_RESTART,            /* if running stop and then start */
  56
  57         _JOB_TYPE_MAX,
  58         _JOB_TYPE_INVALID = -1
  59 };
  60
  61 enum JobState {
  62         JOB_WAITING,
  63         JOB_RUNNING,
  64         _JOB_STATE_MAX,
  65         _JOB_STATE_INVALID = -1
  66 };
  67
  68 enum JobMode {
  69         JOB_FAIL,                /* Fail if a conflicting job is already queued */
  70         JOB_REPLACE,             /* Replace an existing conflicting job */
  71         JOB_ISOLATE,             /* Start a unit, and stop all others */
  72         JOB_IGNORE_DEPENDENCIES, /* Ignore both requirement and ordering dependencies */
  73         JOB_IGNORE_REQUIREMENTS, /* Ignore requirement dependencies */
  74         _JOB_MODE_MAX,
  75         _JOB_MODE_INVALID = -1
  76 };
  77
  78 enum JobResult {
  79         JOB_DONE,
  80         JOB_CANCELED,
  81         JOB_TIMEOUT,
  82         JOB_FAILED,
  83         JOB_DEPENDENCY,
  84         JOB_SKIPPED,
  85         _JOB_RESULT_MAX,
  86         _JOB_RESULT_INVALID = -1
  87 };
  88
  89 struct JobDependency {
  90         /* Encodes that the 'subject' job needs the 'object' job in
  91          * some way. This structure is used only while building a transaction. */
  92         Job *subject;
  93         Job *object;
  94
  95         LIST_FIELDS(JobDependency, subject);
  96         LIST_FIELDS(JobDependency, object);
  97
  98         bool matters;
  99         bool conflicts;
 100 };
 101
 102 struct Job {
 103         Manager *manager;
 104         Unit *unit;
 105
 106         LIST_FIELDS(Job, transaction);
 107         LIST_FIELDS(Job, run_queue);
 108         LIST_FIELDS(Job, dbus_queue);
 109
 110         LIST_HEAD(JobDependency, subject_list);
 111         LIST_HEAD(JobDependency, object_list);
 112
 113         /* Used for graph algs as a "I have been here" marker */
 114         Job* marker;
 115         unsigned generation;
 116
 117         uint32_t id;
 118
 119         JobType type;
 120         JobState state;
 121
 122         Watch timer_watch;
 123
 124         /* Note that this bus object is not ref counted here. */
 125         DBusConnection *bus;
 126         char *bus_client;
 127
 128         JobResult result;
 129
 130         bool installed:1;
 131         bool in_run_queue:1;
 132         bool matters_to_anchor:1;
 133         bool override:1;
 134         bool in_dbus_queue:1;
 135         bool sent_dbus_new_signal:1;
 136         bool ignore_order:1;
 137 };
 138
 139 Job* job_new(Manager *m, JobType type, Unit *unit);
 140 void job_free(Job *job);
 141 void job_dump(Job *j, FILE*f, const char *prefix);
 142
 143 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts);
 144 void job_dependency_free(JobDependency *l);
 145
 146 bool job_is_anchor(Job *j);
 147
 148 int job_merge(Job *j, Job *other);
 149
 150 JobType job_type_lookup_merge(JobType a, JobType b);
 151
 152 static inline int job_type_merge(JobType *a, JobType b) {
 153         JobType t = job_type_lookup_merge(*a, b);
 154         if (t < 0)
 155                 return -EEXIST;
 156         *a = t;
 157         return 0;
 158 }
 159
 160 static inline bool job_type_is_mergeable(JobType a, JobType b) {
 161         return job_type_lookup_merge(a, b) >= 0;
 162 }
 163
 164 static inline bool job_type_is_conflicting(JobType a, JobType b) {
 165         return !job_type_is_mergeable(a, b);
 166 }
 167
 168 static inline bool job_type_is_superset(JobType a, JobType b) {
 169         /* Checks whether operation a is a "superset" of b in its actions */
 170         return a == job_type_lookup_merge(a, b);
 171 }
 172
 173 bool job_type_is_redundant(JobType a, UnitActiveState b);
 174
 175 bool job_is_runnable(Job *j);
 176
 177 void job_add_to_run_queue(Job *j);
 178 void job_add_to_dbus_queue(Job *j);
 179
 180 int job_start_timer(Job *j);
 181 void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w);
 182
 183 int job_run_and_invalidate(Job *j);
 184 int job_finish_and_invalidate(Job *j, JobResult result);
 185
 186 char *job_dbus_path(Job *j);
 187
 188 const char* job_type_to_string(JobType t);
 189 JobType job_type_from_string(const char *s);
 190
 191 const char* job_state_to_string(JobState t);
 192 JobState job_state_from_string(const char *s);
 193
 194 const char* job_mode_to_string(JobMode t);
 195 JobMode job_mode_from_string(const char *s);
 196
 197 const char* job_result_to_string(JobResult t);
 198 JobResult job_result_from_string(const char *s);
 199
 200 #endif