name.h

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #ifndef foonamehfoo
   4 #define foonamehfoo
   5
   6 #include <stdbool.h>
   7 #include <stdlib.h>
   8
   9 typedef union Name Name;
  10 typedef struct Meta Meta;
  11 typedef struct NameVTable NameVTable;
  12 typedef enum NameType NameType;
  13 typedef enum NameLoadState NameLoadState;
  14 typedef enum NameActiveState NameActiveState;
  15 typedef enum NameDependency NameDependency;
  16
  17 #include "job.h"
  18 #include "manager.h"
  19 #include "set.h"
  20 #include "util.h"
  21 #include "list.h"
  22 #include "socket-util.h"
  23 #include "execute.h"
  24 #include "util.h"
  25
  26 #define NAME_MAX 32
  27 #define DEFAULT_TIMEOUT_USEC (20*USEC_PER_SEC)
  28 #define DEFAULT_RESTART_USEC (100*USEC_PER_MSEC)
  29
  30 enum NameType {
  31         NAME_SERVICE = 0,
  32         NAME_TIMER,
  33         NAME_SOCKET,
  34         NAME_MILESTONE,
  35         NAME_DEVICE,
  36         NAME_MOUNT,
  37         NAME_AUTOMOUNT,
  38         NAME_SNAPSHOT,
  39         _NAME_TYPE_MAX,
  40         _NAME_TYPE_INVALID = -1,
  41 };
  42
  43 enum NameLoadState {
  44         NAME_STUB,
  45         NAME_LOADED,
  46         NAME_FAILED,
  47         _NAME_LOAD_STATE_MAX
  48 };
  49
  50 enum NameActiveState {
  51         NAME_ACTIVE,
  52         NAME_ACTIVE_RELOADING,
  53         NAME_INACTIVE,
  54         NAME_ACTIVATING,
  55         NAME_DEACTIVATING,
  56         _NAME_ACTIVE_STATE_MAX
  57 };
  58
  59 static inline bool NAME_IS_ACTIVE_OR_RELOADING(NameActiveState t) {
  60         return t == NAME_ACTIVE || t == NAME_ACTIVE_RELOADING;
  61 }
  62
  63 static inline bool NAME_IS_ACTIVE_OR_ACTIVATING(NameActiveState t) {
  64         return t == NAME_ACTIVE || t == NAME_ACTIVATING || t == NAME_ACTIVE_RELOADING;
  65 }
  66
  67 static inline bool NAME_IS_INACTIVE_OR_DEACTIVATING(NameActiveState t) {
  68         return t == NAME_INACTIVE || t == NAME_DEACTIVATING;
  69 }
  70
  71 enum NameDependency {
  72         /* Positive dependencies */
  73         NAME_REQUIRES,
  74         NAME_SOFT_REQUIRES,
  75         NAME_WANTS,
  76         NAME_REQUISITE,
  77         NAME_SOFT_REQUISITE,
  78
  79         /* Inverse of the above */
  80         NAME_REQUIRED_BY,       /* inverse of 'requires' and 'requisite' is 'required_by' */
  81         NAME_SOFT_REQUIRED_BY,  /* inverse of 'soft_requires' and 'soft_requisite' is 'soft_required_by' */
  82         NAME_WANTED_BY,         /* inverse of 'wants' */
  83
  84         /* Negative dependencies */
  85         NAME_CONFLICTS,         /* inverse of 'conflicts' is 'conflicts' */
  86
  87         /* Order */
  88         NAME_BEFORE,            /* inverse of before is after and vice versa */
  89         NAME_AFTER,
  90
  91         _NAME_DEPENDENCY_MAX,
  92         _NAME_DEPENDENCY_INVALID = -1
  93 };
  94
  95 struct Meta {
  96         Manager *manager;
  97         NameType type;
  98         NameLoadState load_state;
  99
 100         char *id; /* One name is special because we use it for identification. Points to an entry in the names set */
 101
 102         Set *names;
 103         Set *dependencies[_NAME_DEPENDENCY_MAX];
 104
 105         char *description;
 106
 107         /* If there is something to do with this name, then this is
 108          * the job for it */
 109         Job *job;
 110
 111         bool linked:1;
 112         bool in_load_queue:1;
 113
 114         usec_t active_enter_timestamp;
 115         usec_t active_exit_timestamp;
 116
 117         /* Load queue */
 118         LIST_FIELDS(Meta, load_queue);
 119 };
 120
 121 #include "service.h"
 122 #include "timer.h"
 123 #include "socket.h"
 124 #include "milestone.h"
 125 #include "device.h"
 126 #include "mount.h"
 127 #include "automount.h"
 128 #include "snapshot.h"
 129
 130 union Name {
 131         Meta meta;
 132         Service service;
 133         Timer timer;
 134         Socket socket;
 135         Milestone milestone;
 136         Device device;
 137         Mount mount;
 138         Automount automount;
 139         Snapshot snapshot;
 140 };
 141
 142 struct NameVTable {
 143         const char *suffix;
 144
 145         int (*init)(Name *n);
 146         void (*done)(Name *n);
 147
 148         void (*dump)(Name *n, FILE *f, const char *prefix);
 149
 150         int (*start)(Name *n);
 151         int (*stop)(Name *n);
 152         int (*reload)(Name *n);
 153
 154
 155         bool (*can_reload)(Name *n);
 156
 157         /* Boils down the more complex internal state of this name to
 158          * a simpler one that the engine can understand */
 159         NameActiveState (*active_state)(Name *n);
 160
 161         void (*fd_event)(Name *n, int fd, uint32_t events);
 162         void (*sigchld_event)(Name *n, pid_t pid, int code, int status);
 163         void (*timer_event)(Name *n, int id, uint64_t n_elapsed);
 164
 165         void (*retry)(Name *n);
 166 };
 167
 168 extern const NameVTable * const name_vtable[_NAME_TYPE_MAX];
 169
 170 #define NAME_VTABLE(n) name_vtable[(n)->meta.type]
 171
 172 /* For casting a name into the various name types */
 173 #define DEFINE_CAST(UPPERCASE, MixedCase)                               \
 174         static inline MixedCase* UPPERCASE(Name *name) {                \
 175                 if (!name || name->meta.type != NAME_##UPPERCASE)       \
 176                         return NULL;                                    \
 177                                                                         \
 178                 return (MixedCase*) name;                               \
 179         }
 180
 181 /* For casting the various name types into a name */
 182 #define NAME(o) ((Name*) (o))
 183
 184 DEFINE_CAST(SOCKET, Socket);
 185 DEFINE_CAST(TIMER, Timer);
 186 DEFINE_CAST(SERVICE, Service);
 187 DEFINE_CAST(MILESTONE, Milestone);
 188 DEFINE_CAST(DEVICE, Device);
 189 DEFINE_CAST(MOUNT, Mount);
 190 DEFINE_CAST(AUTOMOUNT, Automount);
 191 DEFINE_CAST(SNAPSHOT, Snapshot);
 192
 193 bool name_type_can_start(NameType t);
 194 bool name_type_can_reload(NameType t);
 195 bool name_can_reload(Name *n);
 196 #define name_can_start(n) name_type_can_start((n)->meta.type)
 197
 198 NameType name_type_from_string(const char *n);
 199 bool name_is_valid(const char *n);
 200
 201 Name *name_new(Manager *m);
 202 void name_free(Name *name);
 203 int name_link(Name *name);
 204 int name_link_names(Name *name, bool replace);
 205 int name_merge(Name *name, Name *other);
 206 int name_sanitize(Name *n);
 207 int name_load_fragment_and_dropin(Name *n);
 208 int name_load(Name *name);
 209 const char* name_id(Name *n);
 210 const char *name_description(Name *n);
 211
 212 int name_add_name(Name *n, const char *text);
 213
 214 NameActiveState name_active_state(Name *name);
 215
 216 void name_dump(Name *n, FILE *f, const char *prefix);
 217
 218 int name_start(Name *n);
 219 int name_stop(Name *n);
 220 int name_reload(Name *n);
 221
 222 void name_notify(Name *n, NameActiveState os, NameActiveState ns);
 223
 224 int name_watch_fd(Name *n, int fd, uint32_t events);
 225 void name_unwatch_fd(Name *n, int fd);
 226
 227 int name_watch_pid(Name *n, pid_t pid);
 228 void name_unwatch_pid(Name *n, pid_t pid);
 229
 230 int name_watch_timer(Name *n, usec_t delay, int *id);
 231 void name_unwatch_timer(Name *n, int *id);
 232
 233 char *name_change_suffix(const char *t, const char *suffix);
 234
 235 bool name_job_is_applicable(Name *n, JobType j);
 236
 237 int name_add_dependency(Name *n, NameDependency d, Name *other);
 238
 239 #endif