What I mean by passive versus active init systems
I have in the past talked about passive versus active init systems without quite defining what I meant by that, except sort of through context. Since this is a significant division between init systems that dictates a lot of other things, I've decided to fix that today.
Put simply, an active init system is one that actively tracks the status of services as part of its intrinsic features; a passive init system is one that does not. The minimum behavior of an active init system is that it knows what services have been activated and not later deactivated. Better active init systems know whether services are theoretically still active or if they've failed on their own.
(Systemd, upstart, and Solaris's SMF are all active init systems.
In general any 'event-based' init system that starts services in
response to events will need to be active, because it needs to know
which services have already been started and which ones haven't and
thus are candidates for starting now. System V init's
scripts are a passive init system, although
/etc/inittab is an
active one. Most modern daemon supervision systems are active
One direct consequence is that an active init system essentially
has to do all service starting and stopping itself, because this
is what lets it maintain an accurate record of what services are
active. You may run commands to do this, but they have to talk to
the init system itself. By contrast, in a passive init system the
commands you run to start and stop services can be and often are
just shell scripts; this is the archetype of System V
scripts. You can even legitimately start and stop services outside
of the scripts at all, although things may get a bit confused.
(In the *BSDs things can be even simpler in that you don't have scripts and you may just run the daemons. I know that OpenBSD tends to work this way but I'm not sure if FreeBSD restarts stuff quite that directly.)
An active init system is also usually more communicative with the
outside world. Since it knows the state of services it's common for
the init system to have a way to report this status to people who
ask, and of course it has to have some way of being told either to
start and stop services or at least that particular services have
started and stopped. Passive init systems are much less talkative;
System V init basically has 'change runlevel' and 'reread
and that's about it as far its communication goes (and it doesn't
even directly tell you what the runlevel is; that's written to a
file that you read).
Once you start down the road to an active init system, in practice you wind up wanting some way to track daemon processes so you can know if a service has died. Without this an active init system is basically flying blind in that it knows what theoretically started okay but it doesn't necessarily know what's still running. This can be done by requiring cooperative processes that don't do things like detach themselves from their parents or it can be done with various system specific Unix extensions to track groups of processes even if they try to wander off on their own.
As we can see from this, active init systems are more complicated than passive ones. Generally the more useful features they offer and the more general they are the more complicated they will be. A passive init system can be done with shell scripts; an attractive active one requires some reasonably sophisticated C programming.
PS: An active init system that notices when services die can offer a feature where it will restart them for you. In practice most active init systems aren't set up to do this for most services for various reasons (that may or may not be good ones).
(This entry was partly sparked by reading parts of this mail
showed up in my
Referer logs because it linked to some of my other