8 #include <unordered_set>
15 #include "service-listener.h"
16 #include "service-constants.h"
17 #include "load-service.h"
19 #include "dinit-log.h"
20 #include "options-processing.h" // TODO maybe remove, service_dir_pathlist can be moved?
23 * This header defines service_record, a data record maintaining information about a service,
24 * and service_set, a set of interdependent service records. It also defines some associated
25 * types and exceptions.
29 * Services have both a current state and a desired state. The desired state can be
30 * either STARTED or STOPPED. The current state can also be STARTING or STOPPING.
31 * A service can be "pinned" in either the STARTED or STOPPED states to prevent it
32 * from leaving that state until it is unpinned.
34 * The total state is a combination of the two, current and desired:
35 * STOPPED/STOPPED : stopped and will remain stopped
36 * STOPPED/STARTED : stopped (pinned), must be unpinned to start
37 * STARTING/STARTED : starting, but not yet started. Dependencies may also be starting.
38 * STARTING/STOPPED : as above, but the service will be stopped again as soon as it has
40 * STARTED/STARTED : running and will continue running.
41 * STARTED/STOPPED : started (pinned), must be unpinned to stop
42 * STOPPING/STOPPED : stopping and will stop. Dependents may be stopping.
43 * STOPPING/STARTED : as above, but the service will be re-started again once it stops.
45 * A scripted service is in the STARTING/STOPPING states during the script execution.
46 * A process service is in the STOPPING state when it has been signalled to stop, and is
47 * in the STARTING state when waiting for dependencies to start or for the exec() call in
48 * the forked child to complete and return a status.
50 * Acquisition/release:
52 * Each service has a dependent-count ("required_by"). This starts at 0, adds 1 if the
53 * service has explicitly been started (i.e. "start_explicit" is true), and adds 1 for
54 * each dependent service which is not STOPPED (including dependents with a soft dependency).
55 * When required_by transitions to 0, the service is stopped (unless it is pinned). When
56 * require_by transitions from 0, the service is started (unless pinned).
58 * So, in general, the dependent-count determines the desired state (STARTED if the count
59 * is greater than 0, otherwise STOPPED). However, a service can be issued a stop-and-take
60 * down order (via `stop(true)'); this will first stop dependent services, which may restart
61 * and cancel the stop of the former service. Finally, a service can be force-stopped, which
62 * means that its stop process cannot be cancelled (though it may still be put in a desired
63 * state of STARTED, meaning it will start immediately upon stopping).
67 * A service may be "pinned" in either STARTED or STOPPED states (or even both). Once it
68 * reaches a pinned state, a service will not leave that state, though its desired state
69 * may still be set. (Note that pinning prevents, but never causes, state transition).
71 * The priority of the different state deciders is:
74 * - desired state (which is manipulated by require/release operations)
76 * So a forced stop cannot occur until the service is not pinned started, for instance.
78 * Two-phase transition
79 * --------------------
80 * Transition between states occurs in two phases: propagation and execution. In both phases
81 * a linked-list queue is used to keep track of which services need processing; this avoids
82 * recursion (which would be of unknown depth and therefore liable to stack overflow).
84 * In the propagation phase, acquisition/release messages are processed, and desired state may be
85 * altered accordingly. Start and stop requests are also propagated in this phase. The state may
86 * be set to STARTING or STOPPING to reflect the desired state, but will never be set to STARTED
87 * or STOPPED (that happens in the execution phase).
89 * The two-phase transition is needed to avoid problem where a service that becomes STOPPED has
90 * an incorrect acquisition count, which may cause it to restart when it should not. The
91 * propagation phase allows the acquisition count to settle before the transition to the STOPPED
92 * state occurs, and the decision whether to restart can then be made based on the (correct)
95 * Propagation variables:
96 * prop_acquire: the service has transitioned to an acquired state and must issue an acquire
98 * prop_release: the service has transitioned to a released state and must issue a release on
101 * prop_start: the service should start
102 * prop_stop: the service should stop
104 * Note that "prop_acquire"/"prop_release" form a pair which cannot both be set at the same time
105 * which is enforced via explicit checks. For "prop_start"/"prop_stop" this occurs implicitly.
107 * In the execution phase, actions are taken to achieve the desired state. Actual state may
108 * transition according to the current and desired states. Processes can be sent signals, etc
109 * in order to stop them. A process can restart if it stops, but it does so by raising prop_start
110 * which needs to be processed in a second transition phase. Seeing as starting never causes
111 * another process to stop, the transition-execute-transition cycle always ends at the 2nd
112 * transition stage, at the latest.
115 class service_record;
117 class base_process_service;
119 /* Service dependency record */
122 service_record * from;
126 /* Whether the 'from' service is waiting for the 'to' service to start */
128 /* Whether the 'from' service is holding an acquire on the 'to' service */
131 const dependency_type dep_type;
133 // Check if the dependency is a hard dependency (including milestone still waiting).
136 return dep_type == dependency_type::REGULAR
137 || (dep_type == dependency_type::MILESTONE && waiting_on);
140 service_dep(service_record * from, service_record * to, dependency_type dep_type_p) noexcept
141 : from(from), to(to), waiting_on(false), holding_acq(false), dep_type(dep_type_p)
144 service_dep(const service_dep &) = delete;
145 void operator=(const service_dep &) = delete;
147 service_record * get_from() const noexcept
152 service_record * get_to() const noexcept
158 /* preliminary service dependency information */
162 service_record * const to;
163 dependency_type const dep_type;
165 prelim_dep(service_record *to_p, dependency_type dep_type_p) : to(to_p), dep_type(dep_type_p)
171 // service_record: base class for service record containing static information
172 // and current state of each service.
174 // This abstract base class defines the dependency behaviour of services. The actions to actually bring a
175 // service up or down are specified by subclasses in the virtual methods (see especially bring_up() and
181 using string = std::string;
182 using time_val = dasynq::time_val;
186 service_type_t record_type; // service_type_t::DUMMY, PROCESS, SCRIPTED, or INTERNAL
188 // 'service_state' can be any valid state: STARTED, STARTING, STOPPING, STOPPED.
189 // 'desired_state' is only set to final states: STARTED or STOPPED.
190 service_state_t service_state = service_state_t::STOPPED;
191 service_state_t desired_state = service_state_t::STOPPED;
196 service_flags_t onstart_flags;
198 string logfile; // log file name, empty string specifies /dev/null
200 bool auto_restart : 1; // whether to restart this (process) if it dies unexpectedly
201 bool smooth_recovery : 1; // whether the service process can restart without bringing down service
203 bool pinned_stopped : 1;
204 bool pinned_started : 1;
205 bool waiting_for_deps : 1; // if STARTING, whether we are waiting for dependencies/console
206 // if STOPPING, whether we are waiting for dependents to stop
207 bool waiting_for_console : 1; // waiting for exclusive console access (while STARTING)
208 bool have_console : 1; // whether we have exclusive console access (STARTING/STARTED)
209 bool waiting_for_execstat : 1; // if we are waiting for exec status after fork()
210 bool start_explicit : 1; // whether we are are explicitly required to be started
212 bool prop_require : 1; // require must be propagated
213 bool prop_release : 1; // release must be propagated
214 bool prop_failure : 1; // failure to start must be propagated
218 bool restarting : 1; // re-start after stopping
219 bool start_failed : 1; // failed to start (reset when begins starting)
220 bool start_skipped : 1; // start was skipped by interrupt
222 int required_by = 0; // number of dependents wanting this service to be started
224 // list of dependencies
225 typedef std::list<service_dep> dep_list;
227 // list of dependents
228 typedef std::list<service_dep *> dpt_list;
230 dep_list depends_on; // services this one depends on
231 dpt_list dependents; // services depending on this one
233 service_set *services; // the set this service belongs to
235 std::unordered_set<service_listener *> listeners;
238 bool force_stop; // true if the service must actually stop. This is the
239 // case if for example the process dies; the service,
240 // and all its dependencies, MUST be stopped.
242 int term_signal = -1; // signal to use for process termination
244 string socket_path; // path to the socket for socket-activation service
245 int socket_perms; // socket permissions ("mode")
246 uid_t socket_uid = -1; // socket user id or -1
247 gid_t socket_gid = -1; // socket group id or -1
249 stopped_reason_t stop_reason = stopped_reason_t::NORMAL; // reason why stopped
251 string start_on_completion; // service to start when this one completes
253 // Data for use by service_set
257 lld_node<service_record> console_queue_node;
259 // Propagation and start/stop queues
260 lls_node<service_record> prop_queue_node;
261 lls_node<service_record> stop_queue_node;
265 // Service has actually stopped (includes having all dependents
266 // reaching STOPPED state).
267 void stopped() noexcept;
269 // Service has successfully started
270 void started() noexcept;
272 // Service failed to start (only called when in STARTING state).
273 // dep_failed: whether failure is recorded due to a dependency failing
274 // immediate_stop: whether to set state as STOPPED and handle complete stop.
275 void failed_to_start(bool dep_failed = false, bool immediate_stop = true) noexcept;
277 // A dependency has reached STARTED state
278 void dependency_started() noexcept;
280 void all_deps_started() noexcept;
282 // Start all dependencies, return true if all have started
283 bool start_check_dependencies() noexcept;
285 // Check whether all dependencies have started (i.e. whether we can start now)
286 bool check_deps_started() noexcept;
288 // Whether a STOPPING service can immediately transition to STARTED.
289 bool can_interrupt_stop() noexcept
291 return waiting_for_deps && ! force_stop;
294 // A dependent has reached STOPPED state
295 void dependent_stopped() noexcept;
297 // check if all dependents have stopped
298 bool stop_check_dependents() noexcept;
300 // issue a stop to all dependents, return true if they are all already stopped
301 bool stop_dependents() noexcept;
303 void require() noexcept;
304 void release(bool issue_stop = true) noexcept;
305 void release_dependencies() noexcept;
307 // Check if service is, fundamentally, stopped.
308 bool is_stopped() noexcept
310 return service_state == service_state_t::STOPPED
311 || (service_state == service_state_t::STARTING && waiting_for_deps);
314 void notify_listeners(service_event_t event) noexcept
316 for (auto l : listeners) {
317 l->service_event(this, event);
321 // Queue to run on the console. 'acquired_console()' will be called when the console is available.
322 // Has no effect if the service has already queued for console.
323 void queue_for_console() noexcept;
325 // Release console (console must be currently held by this service)
326 void release_console() noexcept;
328 // Started state reached
329 bool process_started() noexcept;
331 // Called on transition of desired state from stopped to started (or unpinned stop)
332 void do_start() noexcept;
334 // Begin stopping, release activation.
335 void do_stop() noexcept;
337 // Set the service state
338 void set_state(service_state_t new_state) noexcept
340 service_state = new_state;
343 // Virtual functions, to be implemented by service implementations:
345 // Do any post-dependency startup; return false on failure
346 virtual bool bring_up() noexcept;
348 // All dependents have stopped, and this service should proceed to stop.
349 virtual void bring_down() noexcept;
351 // Whether a STARTING service can immediately transition to STOPPED (as opposed to
352 // having to wait for it reach STARTED and then go through STOPPING).
353 virtual bool can_interrupt_start() noexcept
355 return waiting_for_deps;
358 // Whether a STARTING service can transition to its STARTED state, once all
359 // dependencies have started.
360 virtual bool can_proceed_to_start() noexcept
365 // Interrupt startup. Returns true if service start is fully cancelled; returns false if cancel order
366 // issued but service has not yet responded (state will be set to STOPPING).
367 virtual bool interrupt_start() noexcept;
369 // The service is becoming inactive - i.e. it has stopped and will not be immediately restarted. Perform
370 // any appropriate cleanup.
371 virtual void becoming_inactive() noexcept { }
375 service_record(service_set *set, const string &name)
376 : service_name(name), service_state(service_state_t::STOPPED),
377 desired_state(service_state_t::STOPPED), auto_restart(false), smooth_recovery(false),
378 pinned_stopped(false), pinned_started(false), waiting_for_deps(false),
379 waiting_for_console(false), have_console(false), waiting_for_execstat(false),
380 start_explicit(false), prop_require(false), prop_release(false), prop_failure(false),
381 prop_start(false), prop_stop(false), restarting(false), start_failed(false),
382 start_skipped(false), force_stop(false)
385 record_type = service_type_t::DUMMY;
389 service_record(service_set *set, const string &name, service_type_t record_type_p,
390 const std::list<prelim_dep> &deplist_p)
391 : service_record(set, name)
395 this->record_type = record_type_p;
398 for (auto & pdep : deplist_p) {
399 auto b = depends_on.emplace(depends_on.end(), this, pdep.to, pdep.dep_type);
401 pdep.to->dependents.push_back(&(*b));
404 // we'll roll back one now and re-throw:
405 depends_on.pop_back();
411 for (auto & dep : depends_on) {
412 dep.get_to()->dependents.pop_back();
418 service_record(const service_record &) = delete;
419 void operator=(const service_record &) = delete;
421 virtual ~service_record() noexcept
425 // Get the type of this service record
426 service_type_t get_type() noexcept
431 // begin transition from stopped to started state or vice versa depending on current and desired state
432 void execute_transition() noexcept;
434 void do_propagation() noexcept;
436 // Console is available.
437 void acquired_console() noexcept;
439 // Get the target (aka desired) state.
440 service_state_t get_target_state() noexcept
442 return desired_state;
445 // Is the service explicitly marked active?
446 bool is_marked_active() noexcept
448 return start_explicit;
451 // Set logfile, should be done before service is started
452 void set_log_file(const string &logfile)
454 this->logfile = logfile;
457 // Set whether this service should automatically restart when it dies
458 void set_auto_restart(bool auto_restart) noexcept
460 this->auto_restart = auto_restart;
463 void set_smooth_recovery(bool smooth_recovery) noexcept
465 this->smooth_recovery = smooth_recovery;
468 // Set "on start" flags (commands)
469 void set_flags(service_flags_t flags) noexcept
471 this->onstart_flags = flags;
474 void set_pid_file(string &&pid_file) noexcept
476 this->pid_file = std::move(pid_file);
479 void set_socket_details(string &&socket_path, int socket_perms, uid_t socket_uid, uid_t socket_gid)
482 this->socket_path = std::move(socket_path);
483 this->socket_perms = socket_perms;
484 this->socket_uid = socket_uid;
485 this->socket_gid = socket_gid;
488 // Set the service that this one "chains" to. When this service completes, the named service is started.
489 void set_chain_to(string &&chain_to)
491 start_on_completion = std::move(chain_to);
494 const std::string &get_name() const noexcept { return service_name; }
495 service_state_t get_state() const noexcept { return service_state; }
497 void start(bool activate = true) noexcept; // start the service
498 void stop(bool bring_down = true) noexcept; // stop the service
499 bool restart() noexcept; // restart the service, returns true iff restart issued
501 void forced_stop() noexcept; // force-stop this service and all dependents
503 // Pin the service in "started" state (when it reaches the state)
504 void pin_start() noexcept
506 pinned_started = true;
509 // Pin the service in "stopped" state (when it reaches the state)
510 void pin_stop() noexcept
512 pinned_stopped = true;
515 // Remove both "started" and "stopped" pins. If the service is currently pinned
516 // in either state but would naturally be in the opposite state, it will immediately
517 // commence starting/stopping.
518 void unpin() noexcept;
520 // Is this a dummy service (used only when loading a new service)?
521 bool is_dummy() noexcept
523 return record_type == service_type_t::DUMMY;
526 bool did_start_fail() noexcept
531 bool was_start_skipped() noexcept
533 return start_skipped;
536 // Add a listener. A listener must only be added once. May throw std::bad_alloc.
537 void add_listener(service_listener * listener)
539 listeners.insert(listener);
542 // Remove a listener.
543 void remove_listener(service_listener * listener) noexcept
545 listeners.erase(listener);
548 // Assuming there is one reference (from a control link), return true if this is the only reference,
549 // or false if there are others (including dependents).
550 bool has_lone_ref() noexcept
552 if (! dependents.empty()) return false;
553 auto i = listeners.begin();
554 return (++i == listeners.end());
557 // Prepare this service to be unloaded.
558 void prepare_for_unload() noexcept
560 // Remove all dependencies:
561 for (auto &dep : depends_on) {
562 auto &dep_dpts = dep.get_to()->dependents;
563 dep_dpts.erase(std::find(dep_dpts.begin(), dep_dpts.end(), &dep));
568 // Why did the service stop?
569 stopped_reason_t get_stop_reason()
574 bool is_waiting_for_console()
576 return waiting_for_console;
584 virtual pid_t get_pid()
589 virtual int get_exit_status()
594 dep_list & get_dependencies()
599 dpt_list & get_dependents()
604 // Add a dependency. Caller must ensure that the services are in an appropriate state and that
605 // a circular dependency chain is not created. Propagation queues should be processed after
606 // calling this. May throw std::bad_alloc.
607 service_dep & add_dep(service_record *to, dependency_type dep_type)
609 depends_on.emplace_back(this, to, dep_type);
611 to->dependents.push_back(& depends_on.back());
614 depends_on.pop_back();
618 if (dep_type == dependency_type::REGULAR) {
619 if (service_state == service_state_t::STARTING || service_state == service_state_t::STARTED) {
621 depends_on.back().holding_acq = true;
625 return depends_on.back();
628 // Remove a dependency, of the given type, to the given service. Propagation queues should be processed
630 void rm_dep(service_record *to, dependency_type dep_type) noexcept
632 for (auto i = depends_on.begin(); i != depends_on.end(); i++) {
634 if (dep.get_to() == to && dep.dep_type == dep_type) {
635 for (auto j = to->dependents.begin(); ; j++) {
637 to->dependents.erase(j);
641 if (dep.holding_acq) {
650 // Start a speficic dependency of this service. Should only be called if this service is in an
651 // appropriate state (started, starting). The dependency is marked as holding acquired; when
652 // this service stops, the dependency will be released and may also stop.
653 void start_dep(service_dep &dep)
655 if (! dep.holding_acq) {
656 dep.get_to()->require();
657 dep.holding_acq = true;
662 inline auto extract_prop_queue(service_record *sr) -> decltype(sr->prop_queue_node) &
664 return sr->prop_queue_node;
667 inline auto extract_stop_queue(service_record *sr) -> decltype(sr->stop_queue_node) &
669 return sr->stop_queue_node;
672 inline auto extract_console_queue(service_record *sr) -> decltype(sr->console_queue_node) &
674 return sr->console_queue_node;
678 * A service_set, as the name suggests, manages a set of services.
680 * Other than the ability to find services by name, the service set manages various queues.
681 * One is the queue for processes wishing to acquire the console. There is also a set of
682 * processes that want to start, and another set of those that want to stop. These latter
683 * two "queues" (not really queues since their order is not important) are used to prevent too
684 * much recursion and to prevent service states from "bouncing" too rapidly.
686 * A service that wishes to start or stop puts itself on the start/stop queue; a service that
687 * needs to propagate changes to dependent services or dependencies puts itself on the
688 * propagation queue. Any operation that potentially manipulates the queues must be followed
689 * by a "process queues" order (processQueues() method).
691 * Note that processQueues always repeatedly processes both queues until they are empty. The
692 * process is finite because starting a service can never cause services to stop, unless they
693 * fail to start, which should cause them to stop semi-permanently.
699 std::list<service_record *> records;
700 bool restart_enabled; // whether automatic restart is enabled (allowed)
702 shutdown_type_t shutdown_type = shutdown_type_t::NONE; // Shutdown type, if stopping
704 // Services waiting for exclusive access to the console
705 dlist<service_record, extract_console_queue> console_queue;
707 // Propagation and start/stop "queues" - list of services waiting for processing
708 slist<service_record, extract_prop_queue> prop_queue;
709 slist<service_record, extract_stop_queue> stop_queue;
715 restart_enabled = true;
718 virtual ~service_set()
720 for (auto * s : records) {
725 // Start the specified service. The service will be marked active.
726 void start_service(service_record *svc)
732 // Stop the specified service. Its active mark will be cleared.
733 void stop_service(service_record *svc)
739 // Locate an existing service record.
740 service_record *find_service(const std::string &name) noexcept;
742 // Load a service description, and dependencies, if there is no existing
743 // record for the given name.
745 // service_load_exc (or subclass) on problem with service description
746 // std::bad_alloc on out-of-memory condition
747 virtual service_record *load_service(const char *name)
749 auto r = find_service(name);
751 throw service_not_found(name);
756 // Start the service with the given name. The named service will begin
757 // transition to the 'started' state.
759 // Throws a service_load_exc (or subclass) if the service description
760 // cannot be loaded or is invalid;
761 // Throws std::bad_alloc if out of memory.
762 void start_service(const char *name)
765 service_record *record = load_service(name);
766 service_set::start_service(record);
769 void add_service(service_record *svc)
771 records.push_back(svc);
774 void remove_service(service_record *svc)
776 records.erase(std::find(records.begin(), records.end(), svc));
779 // Get the list of all loaded services.
780 const std::list<service_record *> &list_services() noexcept
785 // Add a service record to the state propagation queue. The service record will have its
786 // do_propagation() method called when the queue is processed.
787 void add_prop_queue(service_record *service) noexcept
789 if (! prop_queue.is_queued(service)) {
790 prop_queue.insert(service);
794 // Add a service record to the stop queue. The service record will have its
795 // execute_transition() method called when the queue is processed.
796 void add_transition_queue(service_record *service) noexcept
798 if (! stop_queue.is_queued(service)) {
799 stop_queue.insert(service);
803 // Process state propagation and start/stop queues, until they are empty.
804 void process_queues() noexcept
806 while (! stop_queue.is_empty() || ! prop_queue.is_empty()) {
807 while (! prop_queue.is_empty()) {
808 auto next = prop_queue.pop_front();
809 next->do_propagation();
811 if (! stop_queue.is_empty()) {
812 auto next = stop_queue.pop_front();
813 next->execute_transition();
818 // Set the console queue tail (returns previous tail)
819 void append_console_queue(service_record * newTail) noexcept
821 bool was_empty = console_queue.is_empty();
822 console_queue.append(newTail);
824 enable_console_log(false);
828 // Pull and dispatch a waiter from the console queue
829 void pull_console_queue() noexcept
831 if (console_queue.is_empty()) {
832 // Discard the log buffer now, because we've potentially blocked output for a while
833 // and allowed it to fill with stale messages. (If not much time has passed, the
834 // request to discard will be ignored anyway).
835 discard_console_log_buffer();
836 enable_console_log(true);
839 service_record * front = console_queue.pop_front();
840 front->acquired_console();
844 void unqueue_console(service_record * service) noexcept
846 if (console_queue.is_queued(service)) {
847 console_queue.unlink(service);
851 // Check if console queue is empty (possibly due to console already having
852 // been assigned to the only queueing service)
853 bool is_console_queue_empty() noexcept
855 return console_queue.is_empty();
858 // Check whether a service is queued for the console
859 bool is_queued_for_console(service_record * service) noexcept
861 return console_queue.is_queued(service);
864 // Notification from service that it is active (state != STOPPED)
865 // Only to be called on the transition from inactive to active.
866 void service_active(service_record *) noexcept;
868 // Notification from service that it is inactive (STOPPED)
869 // Only to be called on the transition from active to inactive.
870 void service_inactive(service_record *) noexcept;
872 // Find out how many services are active (starting, running or stopping,
874 int count_active_services() noexcept
876 return active_services;
879 void stop_all_services(shutdown_type_t type = shutdown_type_t::HALT) noexcept
881 restart_enabled = false;
882 shutdown_type = type;
883 for (std::list<service_record *>::iterator i = records.begin(); i != records.end(); ++i) {
890 bool is_shutting_down() noexcept
892 return !restart_enabled;
895 shutdown_type_t get_shutdown_type() noexcept
897 return shutdown_type;
900 // Get an identifier for the run-time type of the service set (similar to typeid, but without
901 // requiring RTTI to be enabled during compilation).
902 virtual int get_set_type_id()
904 return SSET_TYPE_NONE;
908 // A service set which loads services from one of several service directories.
909 class dirload_service_set : public service_set
911 service_dir_pathlist service_dirs;
914 dirload_service_set() : service_set()
919 dirload_service_set(service_dir_pathlist &&pathlist) : service_set(), service_dirs(std::move(pathlist))
924 dirload_service_set(const dirload_service_set &) = delete;
926 int get_service_dir_count()
928 return service_dirs.size();
931 const char * get_service_dir(int n)
933 return service_dirs[n].get_dir();
936 service_record *load_service(const char *name) override;
938 int get_set_type_id() override
940 return SSET_TYPE_DIRLOAD;