systemd

systemctl restart stops the service and starts a new process, so the PID changes and in-flight work is dropped. systemctl reload runs only the unit's ExecReload= command, leaving the same process running; a unit that defines no ExecReload= rejects reload with an error.

A .timer unit only schedules; the work lives in a separate .service unit that it activates — by default the same-named one. You must enable and start the timer itself (systemctl enable --now backup.timer), not the service.

[Unit] holds Description= and relationship keys such as After=; [Service] holds how to run the process, including ExecStart= and User=; [Install] holds WantedBy= and is read only when the unit is enabled. A key in the wrong section is ignored with a warning.

Requirement and ordering are separate axes in systemd. Requires= only says the other unit must be pulled in and must not fail; it never says "wait for it". Without After=, both units are started in parallel, so either can win the race.

Wants= starts the other unit but tolerates its failure. Requires= makes your unit fail to start alongside it and stop when it is explicitly stopped. BindsTo= is stricter still: your unit stops whenever the bound unit stops for any reason, including a crash.

The journal is volatile. With the default Storage=auto it lives in tmpfs under /run/log/journal and is discarded at shutdown unless /var/log/journal exists. Create that directory, or set Storage=persistent, then restart systemd-journald.

Restart=on-failure restarts only after an unclean exit — a nonzero exit status, a fatal signal, a timeout or a watchdog trip. Restart=always additionally restarts after a clean exit 0. Neither applies to an operator-issued systemctl stop, which is an explicit job, not a failure.

systemd binds and listens on port 8080 itself when the .socket unit starts; the first incoming connection triggers the matching .service, and systemd passes the already-listening descriptor to it as file descriptor 3, so the daemon never binds the port at all.

Timers make each job a supervised unit: output lands in the journal, exit status is recorded, the job runs in its own cgroup with resource limits, it can be ordered against other units, and systemctl list-timers shows every schedule on the host. The cost is two files per job and no portability off systemd.

systemd loads units from /etc/systemd/system (admin, wins), /run/systemd/system (runtime), and /usr/lib/systemd/system (package-owned, loses). Package upgrades rewrite the last one, so put changes in a drop-in created with systemctl edit instead of editing the vendor file.

systemd activates default.target at boot, which is a symlink at /etc/systemd/system/default.target falling back to the one shipped under /usr/lib/systemd/system. Read it with systemctl get-default, change it with systemctl set-default, and override one boot with systemd.unit= on the kernel command line.

ListenStream= creates a connection-oriented listening socket (TCP port or AF_UNIX stream path); ListenDatagram= creates a datagram socket such as UDP. The service started is the one with the same base name — myapp.socket activates myapp.service — unless Service= names another.

The suffix is the unit type: .service supervises a process, .socket owns a listening socket, .timer carries a schedule, .mount a mount point, .path watches files, .slice groups processes for resource control, and .scope adopts processes started outside systemd.

Every journal entry is a set of key=value fields. Names starting with an underscore, like _PID and _SYSTEMD_UNIT, are added by journald from the sender's verified credentials and cannot be forged; the rest, such as PRIORITY and MESSAGE, come from the client.

Under Type=simple, systemd calls a unit active as soon as it has forked the main process — it never asks whether the program is ready, or even whether the binary exists. Use Type=exec to wait for a successful exec, or Type=notify so the service reports READY=1 itself.

With Accept=no systemd passes the listening socket to one long-lived service that accepts connections itself. With Accept=yes systemd accepts each connection and spawns a fresh instance of a template unit per connection, passing only that one connection — the classic inetd model.

OnCalendar= fires at wall-clock times and follows the system clock, time zone and DST. Monotonic directives fire a fixed interval after a reference event — boot for OnBootSec=, the triggered unit's last activation for OnUnitActiveSec= — and ignore clock changes.

Persistent=true makes systemd record each trigger as a timestamp file on disk. When the timer starts and that timestamp is older than the schedule allows, the job runs once immediately to catch up. It applies only to OnCalendar= schedules.

The unit has no [Install] section, so there is nothing telling systemctl where to hook it. WantedBy=multi-user.target makes enable create a symlink to the unit inside /etc/systemd/system/multi-user.target.wants/, which is all that enabling physically does.

After= waits for the other unit to be considered started, which is not the same as ready. For Type=simple that means only that systemd forked the process. A daemon signals real readiness with Type=notify and sd_notify, otherwise the consumer must retry.

network.target only means the network management stack has started, not that any interface is configured. A unit that needs real connectivity must declare both Wants=network-online.target and After=network-online.target, and a wait-online service must be enabled to make that target mean anything.

Measure with journalctl --disk-usage, then run journalctl --rotate followed by --vacuum-size= or --vacuum-time=, because vacuuming only removes archived files. Cap growth permanently with SystemMaxUse= and SystemKeepFree= in journald.conf and restart systemd-journald.

systemd's start rate limiter has tripped: the unit was started more than StartLimitBurst= times (5 by default) within StartLimitIntervalSec= (10s by default), so systemd stopped honouring the restart policy and marked the unit failed. Clear the counter with systemctl reset-failed, then fix the crash.

The service is not reacting to SIGTERM, so systemd waits out TimeoutStopSec= — 90 seconds by default — and then sends SIGKILL. A stop job runs ExecStop= if present, signals the unit's processes with KillSignal=, waits, then escalates. Fix the signal handling rather than shortening the timeout.

systemd already holds the listening socket, and the daemon is still calling bind() on the same port instead of using the descriptor it was handed. Something does occupy 8080 — PID 1. Either the daemon must adopt the passed descriptor, or drop the socket unit.

The listening socket is held by systemd, not by the service process, so restarting the service never closes it. Arriving connections sit queued on that socket and are served once the new process inherits the same descriptor and starts accepting.

Normalize the schedule with systemd-analyze calendar, check arming and elapse times with systemctl list-timers --all and systemctl status on the .timer, then separate the halves: run the paired service by hand with systemctl start and read its status and journal.

Drop-ins merge rather than replace, and list-valued settings such as ExecStart= append, so the unit ended up with two. Reset the list first by assigning the key an empty value, then set the new one — two lines: ExecStart= followed by ExecStart=/new/command.

Disabling only removes the unit's [Install] symlinks, so anything that pulls the unit in as a dependency, or a matching socket, path or timer unit, still activates it. Masking symlinks the unit name to /dev/null under /etc/systemd/system, which makes every activation path fail.