Update Dasynq, again, and update Dinit code to reflect API changes.

Hopefully the Dasynq API is now fairly stable.

Yet another Dasynq update

Pull in latest Dasynq, which means a massive amount of renaming.

Update TODO

Update dasynq to latest HEAD

Use the start queue instead of starting services immediately.

Write log messages which cross the circular buffer boundary atomically,
using writev.

Ignore SIGPIPE.

Make control socket handling safer and fix an inverted logic bug.
queuePacket() now no longer deletes the connection, meaning its
use the service listener is now safe.

Missed processing start/stop queue in one place

Introduce a "stop queue" and "start queue" in ServiceSet, to better
manage service interactions and avoid recursion. Both are implemented
as a singly-linked list of services. The queues are processed one
at a time until empty.

Use _exit instead of exit after fork

Rework control protocol handling a little.

Update dasynq

Use a BidiFdWatcher for control connections. One step closer to
working with kqueue...

Update dasynq

Catch a broader range of exceptions when creating a ControlConn

Fix condition for detecting read failure in process_child_status().

Implement DINIT_CP_RELEASESERVICE command.

Code consistency and documentation update

Map dinit-log log levels to syslog log levels

Enable logging to syslog.

Incorporate latest bugfixes from dasynq

Fix (remove) noexcept specification for init_log().

Full support within the logging subsystem to an external source (fd).

More refactoring in preparation for proper logging support

Minor refactoring

Avoid hanging if a BGPROCESS is not a child of dinit, by probing
status with waitpid() and assuming the process is stopped if it
is not a child.

TODO updates.

Whitespace fixes

No need to link libev anymore.

Refactoring, and actually enable console log in enable_console_log()...

Remove obseleted TODO comment

Add console watch for logging once, then enable and disable as necessary,
rather than constantly adding and removing it.

Update dasynq

Code documentation - ServiceRecord and ServiceSet. Add a few lines on how
require/release operate and control service start/stop.

Suppress "invalid offsetof" warnings.

Release on failure to start.
(Ensures dependencies will stop if they are not otherwise required).

Fix condition in is_log_flushed

Make all log messages go via the log buffer.
Flush the log buffer before exit.

Refactorings.

Fix style inconsistency in CPBuffer: fillTo -> fill_to

There is generally inconsistent style throughout the codebase, but
at least this one class can be self-consistent...

OpenBSD: use __thrsigdivert as a replacement for sigtimedwait.

Make selection of epoll/kqueue backend automatic

Beginnings of kqueue support (far from complete)

Rip out libev, replace with dasynq (new library written for the purpose).

Refactoring. Move buffered output management (variables) into a
class.

Use non-blocking I/O and event notification for console logging.
(needs some cleanup).

Only enable console logging via the service layer (when no services
are using the console).

Introduce method to enable/disable console logging, instead of
using a global variable. (introduce "enable_console_log(bool)",
remove "log_to_console").

Add/correct some comments

Make CPBuffer a template, parameterized by buffer size

Makefile improvements (fix clean target), and build with -fno-rtti
for reduced binary size.

Use $HOME/dinit.d for default service directory if not system init.
Add command line options to specify service directory and control
socket path. Add command line option to run as system init (default
when pid == 1).

Remove some explicit memory deallocation in favor of using unique_ptr.

Use delete[] to delete buffers allocated via new[]
(thank you LLVM static analyzer...)

Remove std::move(...) so that copy ellision can occur.

Add support for unpin command in dinitctl (includes corresponding
control protocol changes)

Add support for pinning services to dinitctl

Make "pinStart" and "start", and "pinStop" and "stop", separate
operations.

"pinStart" and "pinStop" set the pin for the started and stopped
states respectively, but do not attempt to move the service into
the chosen state.

Update README with info on service hierarchy and service states
(especially active vs inactive)

Mark service active if it is started while not active.
(It will mark itself inactive when it stops).

During shutdown, let process attrition occur naturally, instead of forcing
the services down early.

Also, don't restart a service which has desired_state = STARTED if auto-restart
is disabled.

Various changes to match changes to command protocol.

Refactor/fix control commands, add a few start/stop alternatives

Fix stop(). Give it a boolean argument for 2 modes of operation:
One, release the service if it was explicitly started (which will
 bring it down only if it is no longer needed by any active service)
Two, release the service and bring it down (which will also bring
 down any dependent services).

Make sure to initialise all members of ControlConn

Restore "restart" flag functionality. Services no longer auto-restart
just because they are active (required) - they now only do so if
the auto-restart flag has been set for the service.

Cleanups and refactoring.

Largish re-work of how dependencies are handled. The "start" and
"dependentStopped" methods were overloaded in unsound ways.

Add require() and release() methods to make an explicit requirement
on a dependency. A require() is added when the service is explictly
started, or when it is a dependency of such a service (directly),
or when it is a dependency of a service which has been required.

Fix "skip to reply packet" method.

It was possible to skip over an information packet but not read any
further reply, so the packet type test (rbuffer[0] == ...) would not
work correctly.

Refactoring, and one fix: stopping an already-stopped service can be
used to remove its explicitly-started state, and in that case needs
to notify dependencies of complete shutdown.

Introduce "explicitly started" state flag for services, and automatically
stop services which were not explicitly started when they have no
dependents running.

This means that if you start a service, and then stop that service, the
system should return to its original state with no additional services
running.

Fix protocol errors in dinitctl

Add license (Apache license version 2.0).

Update gitignore

Make sure to not write a partial command packet.

dinitctl: recognize and report FAILEDSTART events.

Refactoring: remove unneeded method

Make "dinitctl start" start a service and "dinitctl stop" stop a
service, rather than the other way around...

Change command line and implement stopping of services in dinitctl.

"dinitctl start <servicename>" and "dinit stop <servicename>" now function
as you'd expect.

Rename dinit-start to dinitctl, as I think one command for service
management is probably the best route to take.

Move source files int src directory

Add socket-uid and socket-gid service settings for controlling
activation socket ownership.

Update TODO list

Implement socket activation (single, unix-family socket only)

Add some info about Nosh, another init/service system I just found out about.

Make sure to initialise all state bits

A forced stop at the point of reaching STARTED state should not
actually change the desired state: call start() after stop() if
the desired state is not STOPPED.

Re-read PID file after recovering a BGPROCESS service.

Update TODO (log messages to console should be buffered when a service
is holding the console)

Minor re-organisation and logging improvements

Add support for "bgprocess" services - daemons which fork and put
themselves in the background (but which ideally write their PID
into a file that can be read by Dinit).

If a "scripted" service has no stop command, allow it to stop immediately.

This allows no stop command to be specified if none is needed. (This probably
already worked, but only because Dinit would try to exec "" (the empty string)
when the service stopped, which would fail, and the service would get marked
as stopped anyway).

When performing shutdown, un-pin services after issuing stop.

Fix: scripted service might not have its start/stop registered
if the script finishes too quickly.

Add "smooth-recovery" option for process services.

A process service with smooth-recovery set will restart its
process (if it dies unexpectedly) without bring the service
itself down. I.e the service remains in STARTED state, and
any dependents do not have to be brought down.

Move to asynchronous handling of child exec status.

This gives ever-so-slightly better parallelism, and staves off
potential future priority inversion problems.

Remove the "release_console" on-start flag. It is now redundant.

Various improvements to state transitions.

Introduce a new variable to track if a service is waiting for its
dependencies (starting) or dependents (stopping). In these cases
it is possible to transition directly from STARTING to STOPPED or
from STOPPING to STARTED. This also removes the need for special
handling of "internal" services (which will never transition from
STARTING to STARTED or STOPPING to STOPPED excet via transitions
of their dependencies/dependents).