Provided by: dpkg_1.18.4ubuntu1_amd64 bug

NOME

       start-stop-daemon - avvia e ferma i programmi demone di sistema

SINTASSI

       start-stop-daemon [opzione...] comando

DESCRIZIONE

       start-stop-daemon  viene usato per controllare la creazione e la terminazione dei processi
       a livello di sistema. Usando  una  delle  opzioni  corrispondenti,  start-stop-daemon  può
       essere configurato per trovare le istanze esistenti di un processo in esecuzione.

       Nota:  a  meno che non venga specificata l'opzione --pid o --pidfile, start-stop-daemon si
       comporta in modo simile a killall(1). start-stop-daemon analizza la tabella  dei  processi
       cercando  qualsiasi  processo  che  corrisponde  al  nome, PID del genitore, UID o GID (se
       specificati) di processo. Ogni processo che corrisponde impedirà a --start di  avviare  il
       demone.  Se  viene specificata l'opzione --stop a tutti i processi che corrispondono verrà
       inviato il segnale TERM (o quello specificato con --signal o --retry). Per  i  demoni  che
       hanno  processi  figli  di  lunga  vita che devono sopravvivere ad uno --stop è necessario
       specificare un file PID.

COMANDI

       -S, --start [--] argomenti
              Controlla  l'esistenza  di  un  processo  specifico.  Se  tale   processo   esiste,
              start-stop-daemon  non  fa  nulla  ed  esce  con  lo  stato di errore 1 (0 se viene
              specificato --oknodo). Se tale processo non esiste, viene avviata un'istanza usando
              l'eseguibile  specificato  da  --exec  oppure, se presente, da --startas. Tutti gli
              argomenti specificati dopo -- sulla riga di comando  vengono  passati  immutati  al
              programma che viene avviato.

       -K, --stop
              Controlla  l'esistenza  di  un  processo  specificato.  Se un tale processo esiste,
              start-stop-daemon gli invia il segnale specificato da --signal ed esce con lo stato
              di  errore  0.  Se  tale  processo  non esiste, start-stop-daemon esce con stato di
              errore 1 (0 se viene specificato  --oknodo).  Se  viene  usata  l'opzione  --retry,
              allora start-stop-daemon controllerà che i processi siano stati terminati.

       -T, --status
              Check  for  the  existence of a specified process, and returns an exit status code,
              according to the LSB Init Script Actions (since version 1.16.1).

       -H, --help
              Visualizza informazioni sull'uso ed esce.

       -V, --version
              Visualizza la versione del programma ed esce.

OPZIONI

   Opzioni per corrispondenze
       --pid pid
              Check for a process with the specified pid (since version 1.17.6).  The pid must be
              a number greater than 0.

       --ppid ppid
              Check for a process with the specified parent pid ppid (since version 1.17.7).  The
              ppid must be a number greater than 0.

       -p, --pidfile file-pid
              Controlla se un processo ha creato il file file-pid. Nota: usare questa opzione  di
              corrispondenza  da  sola  può  causare  effetti  su  processi non desiderati, se il
              vecchio processo è stato terminato senza aver potuto rimuovere il file-pid.

       -x, --exec eseguibile
              Cerca i processi che sono istanze  di  questo  eseguibile.  L'argomento  eseguibile
              dovrebbe  essere un nome di percorso assoluto. Nota: questo potrebbe non funzionare
              come  atteso  con  gli  script  interpretati,   dato   che   l'eseguibile   punterà
              all'interprete.  Tenere  in  considerazione  che  faranno  corrispondenza  anche  i
              processi in esecuzione in una chroot, perciò  potrebbero  essere  necessarie  altre
              restrizioni della corrispondenza.

       -n, --name nome-processo
              Cerca  i processi con nome nome-processo. Questo è solitamente il nome del file del
              processo, ma potrebbe essere  stato  cambiato  dal  processo  stesso.  Nota:  nella
              maggior  parte  dei  sistemi questa informazione viene recuperata del nome comm del
              processo nel kernel, che tende ad avere  limiti  di  lunghezza  piuttosto  limitati
              (nell'assunzione che più di 15 caratteri non siano portabili).

       -u, --user nomeutente|uid
              Cerca  i  processi  di proprietà dell'utente specificato da nomeutente o uid. Nota:
              l'uso di questa opzione di corrispondenza  da  sola  farà  sì  che  l'azione  abbia
              effetto su tutti i processi corrispondenti all'utente.

   Opzioni generiche
       -g, --group gruppo|gid
              Modifica in group o gid quando avvia il processo.

       -s, --signal segnale
              Con  --stop specifica il segnale da inviare ai processi che vengono fermati (quello
              predefinito è TERM).

       -R, --retry scadenza|pianificazione
              Con --stop specifica che start-stop-daemon deve controllare se i processi terminano
              effettivamente.  Controlla  ripetutamente se qualsiasi processo corrispondente è in
              esecuzione fino a che nessuno lo è più. Se i processi non terminano, effettua altre
              azioni in base alla pianificazione.

              Se  viene specificata una scadenza invece di una pianificazione, allora viene usata
              la  pianificazione  segnale/scadenza/KILL/scadenza,  dove  segnale  è  il   segnale
              specificato da --signal.

              pianificazione  è  un  elenco di almeno due elementi separati da barre (/); ciascun
              elemento può essere -numero-segnale o [-]nome-segnale, che significa  inviare  quel
              segnale,  o  scadenza,  che  significa  aspettare  che il processo termini per quel
              numero  di  secondi,  oppure  forever,  che  significa  ripetere  il  resto   della
              pianificazione all'infinito, se necessario.

              Se  viene  raggiunta  la fine della pianificazione e non viene specificato forever,
              allora start-stop-daemon esce con stato di  errore  2.  Se  viene  specificata  una
              pianificazione, allora viene ignorato qualsiasi segnale specificato con --signal.

       -a, --startas nomepercorso
              Con  --start,  avvia  il  processo specificato da nomepercorso. Se non specificato,
              viene usato in modo predefinito l'argomento fornito a --exec.

       -t, --test
              Visualizza le azioni che  sarebbero  effettuate  e  imposta  il  valore  restituito
              appropriato, ma non fa alcuna azione.

       -o, --oknodo
              Restituisce  lo  stato  di uscita 0 invece di 1 se non viene (o non verrebbe) fatta
              alcuna azione.

       -q, --quiet
              Non visualizza messaggi informativi; mostra solo i messaggi di errore.

       -c, --chuid nomeutente|uid[:gruppo|gid]
              Change to this username/uid before starting the process. You  can  also  specify  a
              group  by appending a :, then the group or gid in the same way as you would for the
              chown(1) command (user:group).  If a user is specified without a group, the primary
              GID  for  that  user  is  used.   When  using this option you must realize that the
              primary and supplemental groups are set as well, even if the --group option is  not
              specified.  The  --group  option  is only for groups that the user isn't normally a
              member of (like adding per process group membership for generic users like nobody).

       -r, --chroot root
              Cambia la directory e la chroot a root prima di avviare  il  processo.  Notare  che
              anche il filepid viene scritto dopo chroot.

       -d, --chdir percorso
              Cambia  la  directory  a  percorso prima di avviare il processo. Questo viene fatto
              dopo  chroot,  se  viene  usata  l'opzione  -r|--chroot.  Quando  non  specificato,
              start-stop-daemon cambia la directory in quella root prima di avviare il processo.

       -b, --background
              Typically used with programs that don't detach on their own. This option will force
              start-stop-daemon to fork before starting  the  process,  and  force  it  into  the
              background.  Warning: start-stop-daemon cannot check the exit status if the process
              fails to execute for any reason. This is a last  resort,  and  is  only  meant  for
              programs that either make no sense forking on their own, or where it's not feasible
              to add the code for them to do this themselves.

       -C, --no-close
              Do not close any file descriptor when forcing the daemon into the background (since
              version  1.16.5).   Used  for  debugging  purposes to see the process output, or to
              redirect file descriptors to log the process  output.   Only  relevant  when  using
              --background.

       -N, --nicelevel int
              Modifica la priorità del processo prima di avviarlo.

       -P, --procsched politica:priorità
              This  alters  the  process  scheduler  policy  and  priority  of the process before
              starting it (since version 1.15.0).  The priority can be  optionally  specified  by
              appending  a  :  followed  by  the  value. The default priority is 0. The currently
              supported policy values are other, fifo and rr.

       -I, --iosched classe:priorità
              This alters the IO scheduler class and priority of the process before  starting  it
              (since  version 1.15.0).  The priority can be optionally specified by appending a :
              followed by the value. The default priority  is  4,  unless  class  is  idle,  then
              priority  will  always  be  7.  The  currently supported values for class are idle,
              best-effort and real-time.

       -k, --umask maschera
              This sets the umask of the process before starting it (since version 1.13.22).

       -m, --make-pidfile
              Used when starting a program that does not create its own  pid  file.  This  option
              will make start-stop-daemon create the file referenced with --pidfile and place the
              pid into it just before executing the process. Note, the file will only be  removed
              when  stopping the program if --remove-pidfile is used.  Note: This feature may not
              work in all cases. Most notably when the program being executed forks from its main
              process.  Because  of  this,  it  is  usually  only  useful  when combined with the
              --background option.

       --remove-pidfile
              Used when stopping a program that does not remove its own pid file  (since  version
              1.17.19).   This option will make start-stop-daemon remove the file referenced with
              --pidfile after terminating the process.

       -v, --verbose
              Visualizza messaggi informativi dettagliati.

STATO D'USCITA

       0      L'azione richiesta è stata effettuata. Se è stata  specificata  --oknodo,  è  anche
              possibile  che  non  sia stato necessario fare nulla. Ciò può avvenire quando viene
              specificata l'opzione --start e un processo corrispondente  è  già  in  esecuzione,
              oppure quando viene specificata --stop e non c'è alcun processo corrispondente.

       1      Se non è stata specificata --oknodo e non è stato fatto nulla.

       2      Se  sono  state  specificate  --stop  e --retry, ma è stata raggiunta la fine della
              pianificazione e il processo era ancora in esecuzione.

       3      Qualsiasi altro errore.

       Quando si usa il comando --status, vengono restituiti i seguenti codici di stato:

       0      Il programma è in esecuzione.

       1      Il programma non è in esecuzione e il file PID esiste.

       3      Il programma non è in esecuzione.

       4      Non è stato possibile determinare lo stato del programma.

ESEMPIO

       Avvia il demone pippod, a meno che uno non sia già in  esecuzione  (un  processo  chiamato
       pippod, in esecuzione come utente pippod, con PID in pippod.pid):

              start-stop-daemon --start --oknodo --user pippod --name pippod \
                   --pidfile /run/pippod.pid --startas /usr/sbin/pippod \
                   --chuid pippod -- --daemon

       Invia SIGTERM a pippod e attende fino a 5 secondi che esso si fermi:

              start-stop-daemon --stop --oknodo --user pippod --name pippod \
                   --pidfile /run/pippod.pid --retry 5

       Dimostrazione di una pianificazione personalizzata per fermare pippod:

              start-stop-daemon --stop --oknodo --user pippod --name pippod \
                   --pidfile /run/pippod.pid --retry=TERM/30/KILL/5