systemd Type=: simple, forking o notify? Guida
L'unità resta active ma il demone è terminato? Scegli Type= tra simple, exec, forking, oneshot e notify e individua il vero PID principale.
Perché systemd indica un'unità come attiva quando il processo è terminato
Con i valori predefiniti ExitType=main e RemainAfterExit=no, un'unità di servizio systemd resta active finché è in esecuzione l'unico processo che systemd considera il processo principale, mentre Type= nella sezione [Service] determina quale sia questo processo. Se si sceglie il valore errato, systemd finisce per monitorare un wrapper shell o un processo padre di breve durata, mentre il demone interessato termina all'interno della stessa unità. L'unità riporta correttamente lo stato del processo che le è stato indicato di monitorare.
La modifica della policy di riavvio non risolve il problema. Restart= reagisce alle uscite e agli errori dei processi, ad esempio ai timeout, ma non rileva l'uscita di un demone in background quando il PID principale (identificatore del processo) appartiene a un processo ancora in esecuzione. Correggere prima Type=. L'azione che systemd esegue dopo l'uscita effettiva del processo principale è una decisione separata, descritta nella guida a Restart= e RestartSec=.
Che cosa determina realmente Type=
Ogni valore di Type= risponde a due domande contemporaneamente: quando systemd può considerare avviata questa unità e quale processo è quello principale.
La prima risposta controlla l'ordinamento. Un'unità che indica la tua in After= attende che systemd consideri avviata la tua unità. Un Type= che segnala "avviato" troppo presto consente alle unità dipendenti di essere eseguite prima che il servizio possa rispondere.
La seconda risposta controlla il monitoraggio. systemd inserisce ogni processo avviato da un'unità in un cgroup (control group), una funzionalità del kernel che raggruppa i processi per poterli limitare e terminare insieme. Il cgroup è il meccanismo con cui systemctl stop esegue la pulizia: KillMode= ha come valore predefinito control-group, quindi l'arresto di un'unità invia un segnale a ogni processo al suo interno. Il PID principale è un concetto più ristretto. Con i valori predefiniti ExitType=main e RemainAfterExit=no, è l'unico processo la cui terminazione conclude l'unità e il cui codice di uscita contribuisce al risultato dell'unità. La confusione inizia quando si interpreta il cgroup come se fosse il PID principale.
Type=simple segnala l’avvio prima dell’esecuzione del binario
Type=simple è il valore predefinito quando ExecStart= è impostato, non è presente né Type= né BusName= e l’unità non utilizza credenziali. Un’unità che carica credenziali, ad esempio con LoadCredential=, implica invece Type=exec. Con simple, systemd crea il processo, considera immediatamente avviata l’unità e tratta quel processo come PID principale. Le unità dipendenti iniziano subito, prima ancora che il binario del servizio sia stato eseguito.
Questo ultimo dettaglio spiega un problema comune. Anche un errore di battitura nel percorso ExecStart= produce un job di avvio che termina correttamente; l’errore arriva un momento dopo, quando l’esecuzione fallisce. systemd registra questo caso con il codice di uscita 203, che nella propria tabella denomina EXIT_EXEC e definisce come un errore nell’esecuzione effettiva del processo. Pertanto, il completamento senza errori di systemctl start non dimostra che il binario esista.
Usa simple per un programma che rimane in primo piano e non passa autonomamente in background. Questa configurazione copre la maggior parte dei daemon moderni e quasi tutti i programmi scritti autonomamente.
Type=exec attende l'avvio effettivo del programma
Type=exec equivale a simple con un passaggio aggiuntivo. systemd considera l'unità avviata solo dopo che il fork e l'esecuzione del binario sono riusciti. Se il binario manca o un User= non può essere risolto, ora il processo di avvio fallisce direttamente, invece di segnalare il successo e terminare silenziosamente poco dopo.
Type=exec è stato introdotto upstream in systemd 240, ma le distribuzioni lo supportano tramite backport anche nelle versioni precedenti: RHEL 8 lo ha aggiunto in systemd-239-15.el8. Anche le versioni precedenti supportate possono esserne prive: Ubuntu 18.04 resta in ESM fino ad aprile 2028 e il relativo manuale di systemd 237 non elenca exec come tipo supportato. Ubuntu 24.04 include systemd 255 e Debian 13 include systemd 257, alla data di ottobre 2026. Verifica la tua versione con systemctl --version e consulta il manuale systemd.service della distribuzione.
Il costo consiste in un passaggio aggiuntivo di sincronizzazione durante l'avvio. Il vantaggio è un codice di uscita affidabile da systemctl start. Per un programma in primo piano, preferisci exec a simple.
Type=forking e come viene perso il PID principale
Type=forking indica a systemd che il processo in ExecStart= creerà un processo figlio e poi terminerà intenzionalmente. systemd attende la terminazione del primo processo e solo dopo considera avviata l'unità. Il processo figlio rimasto è il demone. Questa pratica risale all'epoca di SysV, quando nessuno supervisionava un demone dopo il ritorno dello script di init e un file PID era l'unica registrazione del processo in esecuzione, una limitazione che è alla base di perché systemd ha sostituito gli script di init.
La difficoltà riguarda l'identità del processo. Il processo avviato da systemd non esiste più, quindi systemd deve determinare quale processo sopravvissuto sia quello principale. Impostare PIDFile= sul file scritto dal demone, normalmente un percorso sotto /run, consente a systemd di leggere il PID da quel file. Quando il file appartiene a un utente senza privilegi, systemd verifica anche che il PID contenuto faccia riferimento a un processo già appartenente a questo servizio. In questo modo un file obsoleto o inserito ad arte, che indica un processo non correlato, viene rifiutato anziché considerato attendibile.
Senza PIDFile= si applica GuessMainPID=, il cui valore predefinito è yes. La deduzione è affidabile solo quando il servizio si stabilizza in un unico processo. Il manuale indica chiaramente il limite: la deduzione può essere errata se il demone è composto da più processi; inoltre, se non è possibile determinare il PID principale, il rilevamento degli errori e il riavvio automatico non funzionano in modo affidabile. Un'unità può anche ritrovarsi con un PID principale pari a 0. In questo caso systemd non tiene sotto controllo alcun processo principale, anche se i processi del demone sono ancora in esecuzione nel cgroup dell'unità.
La maggior parte dei demoni che creano processi figlio dispone anche di un'opzione per restare in primo piano. Usare questa opzione con Type=exec ed eliminare la riga PIDFile=. Meno componenti da gestire significano meno possibilità di perdere il PID.
Type=oneshot per le attività che terminano
Type=oneshot presuppone che il processo venga eseguito e termini. systemd considera l’unità avviata solo dopo la sua terminazione; per questo oneshot è adatto a tutto ciò che un’altra unità deve attendere. È anche il valore predefinito implicito quando un’unità non specifica né Type= né ExecStart=.
Due comportamenti sono specifici di oneshot. È l’unico tipo che accetta più di una riga ExecStart=, che viene eseguita in sequenza. Inoltre, per impostazione predefinita, il timeout di avvio è disabilitato. Di conseguenza, un oneshot che si blocca attende indefinitamente, a meno che non si imposti manualmente TimeoutStartSec=.
Dopo la terminazione del processo, l’unità torna allo stato inattivo. RemainAfterExit=yes la mantiene active senza alcun processo in esecuzione. Questo comportamento rappresenta la versione intenzionale del sintomo descritto all’inizio di questa pagina ed è corretto quando il compito dell’unità consiste nel lasciare uno stato persistente invece di mantenere un processo in esecuzione, ad esempio caricare un ruleset del firewall o avviare uno stack di container. È lo schema alla base di uno stack Docker Compose che torna disponibile dopo un riavvio, in cui l’unità esegue il comando Compose, termina e rimane attiva perché i container avviati continuano a esistere indipendentemente dall’unità. Un’unità oneshot è adatta anche alle attività attivate da una pianificazione, che costituiscono l’altra parte di eseguire un’attività tramite un timer systemd invece di cron.
Type=notify consente al servizio di segnalare quando è pronto
Type=notify trasferisce la decisione al servizio. systemd mantiene aperto il job di avvio finché il processo non invia READY=1 tramite un socket Unix il cui percorso riceve nella variabile d'ambiente NOTIFY_SOCKET. L'interfaccia C è sd_notify(3) e molti server la supportano già.
Questa è la risposta corretta alla domanda «è stato avviato?». simple e exec segnalano l'avvio prima che il servizio abbia letto la configurazione o aperto il socket in ascolto. Di conseguenza, un'unità dipendente può avviarsi troppo presto e fallire la prima connessione. notify segnala l'avvio nel momento in cui il servizio stesso dichiara di essere pronto.
systemd accetta questo messaggio solo dal processo principale. Questo è il significato di NotifyAccess=main, che è implicato da Type=notify. Se il messaggio proviene da un processo figlio o da un processo di supporto, impostare NotifyAccess=all. Uno script shell può chiamare systemd-notify --ready. Quando dispone dei privilegi necessari, systemd-notify invia il messaggio usando il PID del processo padre. In questo modo, uno script che è anche il processo principale passa NotifyAccess=main; in caso contrario, usa il proprio PID e l'unità richiede NotifyAccess=all. Per impostazione predefinita, attende che systemd abbia elaborato il messaggio prima di terminare. Per mantenere questo comportamento, omettere --no-block, che disabilita l'attesa. Un servizio che implementa direttamente il protocollo è più affidabile.
È utile conoscere anche due impostazioni correlate. Type=notify-reload, disponibile a partire da systemd 253, estende lo stesso handshake alle operazioni di ricaricamento. Di conseguenza, systemctl reload restituisce il controllo quando il servizio segnala che il ricaricamento è terminato, invece di restituirlo quando il segnale è stato inviato. A partire da systemd 262, rilasciato a settembre 2026, un servizio notify-reload che invia READY=1 senza intercettare o bloccare il segnale di ricaricamento, ovvero SIGHUP salvo diversa indicazione di ReloadSignal=, non riesce ad avviarsi e restituisce un errore di protocollo. In questo modo non viene terminato da quel segnale durante il primo ricaricamento. WatchdogSec= chiede a un servizio che usa le notifiche di inviare un messaggio keep-alive a intervalli regolari. systemd considera una scadenza mancata un errore.
Type=dbus e Type=idle
Type=dbus attende che il servizio acquisisca un nome su D-Bus, il message bus utilizzato dai servizi di sistema e desktop per comunicare tra loro. Richiede BusName= e diventa il valore predefinito non appena viene impostato BusName=. Usatelo solo per un servizio che registra effettivamente un nome sul bus.
Type=idle si comporta come simple, ma ritarda l'esecuzione del programma finché i job in coda non sono stati distribuiti, con un limite massimo di cinque secondi. Serve a evitare che l'output della console durante il boot si sovrapponga ai messaggi di stato. Non è uno strumento per definire l'ordine di avvio e non va usato per un servizio normale.
Perché uno script wrapper lascia systemd associato al PID errato
Ecco la struttura che produce il sintomo originale.
[Service]
Type=simple
ExecStart=/opt/app/run.sh#!/bin/bash
export APP_ENV=production
/opt/app/bin/server --config /etc/app.yaml &
/opt/app/bin/exporter --port 9101systemd registra la shell come PID principale. La shell rimane in esecuzione mentre exporter viene eseguito in primo piano. Se server termina, la shell non se ne accorge. Di conseguenza, il PID principale è ancora attivo, l'unità è ancora active e Restart= non ha nulla su cui intervenire. Entrambi i processi rimangono sempre nel cgroup dell'unità, quindi systemctl stop continua a eseguire correttamente la pulizia. Si è interrotta la supervisione, non la pulizia.
La correzione dipende dal numero effettivo di processi a esecuzione prolungata gestiti dall'unità.
Se ce n'è uno, sostituisci la shell con il processo.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec sostituisce la shell con il programma indicato e mantiene lo stesso PID. Il PID registrato da systemd appartiene quindi al daemon. Una soluzione ancora migliore consiste nel rimuovere il wrapper. Environment= e EnvironmentFile= trasferiscono le variabili, mentre ExecStartPre= esegue il passaggio di configurazione. In questo modo systemd può avviare direttamente il daemon e conoscerne il PID per costruzione.
Se sono due, nessun singolo PID rappresenta l'unità. Dividili in due unità e stabilisci l'ordine con After= e Wants=. Un'unità per processo è la struttura che systemd supervisiona meglio ed è l'unico modo per assegnare a ciascun processo un comportamento di riavvio indipendente.
Cosa cambia ExitType=cgroup
ExitType= è stato aggiunto in systemd 250. Il valore predefinito è main: l'unità viene considerata arrestata quando termina il processo principale. Con ExitType=cgroup, l'unità viene considerata in esecuzione finché è attivo un processo appartenente al relativo cgroup.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherQuesta opzione risolve un problema specifico. Un launcher che avvia il lavoro effettivo e poi termina, con ExitType=main, farebbe considerare l'unità arrestata da systemd, che terminerebbe i processi ancora attivi. Con ExitType=cgroup, invece, l'unità segue l'intero gruppo.
È importante chiarire cosa non risolve. ExitType=cgroup mantiene attiva un'unità finché è in esecuzione almeno un processo. Di conseguenza, un'unità che contiene due daemon resta attiva anche dopo l'arresto di uno dei due. Risolve il caso del launcher. Non trasforma un'unità in un supervisore per più processi indipendenti. Inoltre, ExitType=cgroup non può essere combinato con Type=oneshot.
Anche la contabilizzazione delle risorse avviene nel cgroup. Di conseguenza, limiti come MemoryMax= e CPUQuota= si applicano a ogni processo avviato dall'unità, indipendentemente da ciò che Type= indica per il PID principale. Questo aspetto è descritto nella sezione limitare memoria e CPU di un servizio con systemd.
Come trovare il processo che systemd sta effettivamente monitorando
Esegui questi controlli, nell’ordine indicato, sull’unità di cui stai verificando il comportamento. Leggi i file dell’unità, poi ciò che systemd tiene sotto controllo e infine confronta i dati con la tabella dei processi.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat stampa il file dell’unità insieme a tutti i drop-in applicabili presenti su disco; questi dati possono differire da quelli caricati da systemd se i file sono stati modificati senza un daemon-reload. systemctl show stampa i valori effettivi, compresi i valori predefiniti che non hai specificato. Prima di proseguire, annota il valore di MainPID.
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls elenca tutti i processi nel cgroup dell’unità. La riga ps descrive l’unico processo supervisionato da systemd. Leggi insieme queste due informazioni. Un MainPID pari a 0 indica che systemd non sta monitorando alcun processo principale, anche se systemd-cgls elenca ancora processi nel cgroup dell’unità. Un MainPID che risolve a una shell mentre il cgroup contiene anche il tuo demone indica il caso del wrapper descritto sopra. Un cgroup con più processi del previsto indica la presenza di un launcher o di un demone che esegue il fork.
systemctl status app.service
journalctl -u app.service -bsystemctl status stampa insieme la riga dello stato e l’albero del cgroup, quindi spesso risponde a entrambe le domande. journalctl -u, limitato a questo boot tramite -b, mostra gli eventi di avvio e arresto registrati da systemd per l’unità, inclusi i codici di uscita rilevati. Se il demone scrive in un proprio file di log invece che nel journal, leggi anche quel file, perché systemd può registrare soltanto ciò che gli viene trasmesso.
Quando modifichi Type=, ricarica la configurazione e riavvia l’unità.
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify analizza il file e segnala le impostazioni che non può accettare. daemon-reload fa rileggere a systemd i file delle unità dal disco. Una modifica a Type= non si applica a un’unità già in esecuzione, quindi il riavvio è necessario.
Poi verifica la modifica. Ricava da systemd-cgls il PID del processo che ti interessa effettivamente e terminane l’esecuzione. Esegui subito dopo systemctl is-active app.service. Con ExitType=main e RemainAfterExit=no, la terminazione del processo principale interrompe quell’istanza in esecuzione, anche se una policy di riavvio può farla ripartire prima della verifica. Se l’unità rimane attiva senza riavviarsi, verifica se systemd sta monitorando un altro processo oppure se l’unità usa ExitType=cgroup o RemainAfterExit=yes.
Quale Type= di systemd usare
- Un programma che resta in primo piano:
Type=exec. - Un programma che supporta la notifica di disponibilità:
Type=notify, enotify-reloadse conferma anche i reload. - Un daemon che richiede di passare in background:
Type=forkingconPIDFile=, oppure l'opzione per restare in primo piano conType=exec. - Uno script che esegue un'attività e termina:
Type=oneshot, oltre aRemainAfterExit=yesquando l'obiettivo era lasciare uno stato persistente. - Un launcher che termina mentre i processi figli continuano a essere eseguiti:
Type=simpleconExitType=cgroup.
Se non sai quale opzione richiede un daemon di terze parti, leggi prima il relativo unit file fornito dal pacchetto. L'esecuzione di systemctl cat su un'unità distribuita dal sistema mostra la scelta Type= del pacchetto insieme agli override locali.
FAQ
Perché la mia unit systemd rimane attiva quando il processo è terminato?
Con i valori predefiniti ExitType=main e RemainAfterExit=no, questo accade perché il processo che systemd considera principale è ancora attivo. Con questi valori, systemd segue un singolo PID principale per servizio, scelto in base a Type=. La causa più comune è uno script wrapper avviato con Type=simple: la shell è il PID principale, quindi la unit rimane attiva quando termina un demone avviato in background dalla shell. Esegui systemctl show -p MainPID app.service, quindi elenca il cgroup della unit con systemd-cgls --unit=app.service e confronta i due risultati.
Qual è la differenza tra Type=simple e Type=exec?
Type=simple considera la unit avviata non appena systemd ha creato il processo, prima che il binario venga eseguito. Di conseguenza, anche un percorso errato in ExecStart= produce un job di avvio riuscito, seguito da un errore. Type=exec attende che l'esecuzione abbia avuto successo, quindi il job di avvio segnala direttamente l'errore. Entrambi considerano lo stesso processo come PID principale. Type=exec è stato introdotto nel progetto systemd a partire dalla versione 240, ma le distribuzioni possono averlo portato nelle versioni precedenti, come ha fatto RHEL 8 in systemd-239-15.el8.
Serve ancora PIDFile= con Type=forking?
Sì, quando il demone scrive un file PID. In sua assenza, systemd ricorre a GuessMainPID=, che è una stima affidabile solo per un servizio che si stabilizza in un singolo processo. Quando la stima è errata o non è possibile effettuarla, il rilevamento degli errori e il riavvio automatico non funzionano in modo affidabile per la unit. Imposta PIDFile= sul percorso esatto in cui il demone scrive il file, normalmente sotto /run.
Quando devo usare RemainAfterExit=yes?
Quando lo scopo della unit è modificare lo stato del sistema invece di mantenere in esecuzione un processo. Una unit Type=oneshot che carica le regole del firewall o avvia uno stack di container termina non appena completa il proprio lavoro. Senza RemainAfterExit=yes, la unit passa direttamente dallo stato di avvio a quello di arresto. Di conseguenza, qualsiasi pulizia ExecStop= viene eseguita subito dopo il completamento del lavoro, invece che quando scegli di arrestare la unit, e systemctl stop non ha più nulla da arrestare. Con questa opzione, la unit rimane attiva senza processi, come previsto in questo caso.
La modifica di Type= richiede daemon-reload?
Sì, e richiede anche il riavvio della unit. systemctl daemon-reload ordina a systemd di rileggere i file delle unit dal disco, ma un'istanza in esecuzione continua a usare il Type= con cui è stata avviata. Esegui sudo systemctl daemon-reload e quindi sudo systemctl restart app.service prima di eseguire i test. In caso contrario, stai ancora osservando il comportamento di supervisione precedente.