Index of Topics

Introduzione ai processi sotto Linux/Unix

Uno dei principali motivi del successo di Unix è senza dubbio dovuto alla sua capacità di multitasking. Per multitasking si intende la possibilità da parte del sistema operativo di far girare contemporaneamente più di una applicazione.

Ogni programma, ogni comando che si lancia, ogni servizio attivo sul sistema da origine a uno o più processi.
Ad ogni processo viene assegnato un numero che lo identifica univocamente, chiamato PID (Process IDentificator). Ogni processo, tranne init (a cui corrisponde il PID 1), è generato da un'altro processo di cui si definisce il PPID (Parent PID). Si parla quindi di processo padre (parent) e processo figlio (child).
Un processo consta di: codice eseguibile, posizione di esecuzione, dati che gestisce, file aperti, ambiente di esecuzione, credenziali.
Quando lo stesso programma è eseguito più volte nel sistema, anche da parte di utenti diversi, alcune parti dello stesso possono essere condivise (shared) in memoria: il codice in esecuzione e le eventuali librerie di sistema caricate, altre parti come i dati, i file aperti, il PID.
Un processo può generare una copia di se stesso (fork), cha ha PID diverso e PPID uguale al proprio PID.

La Schedulazione da parte del kernel
Nel kernel di un sistema operativo lo schedulatore (dispatcher) è responsabile della coordinazione dei processi in esecuzione per gestire i loro accessi alle risorse e assicurare che abbiano accesso alla CPU per un tempo relativo alla loro priorità assegnata, senza rischiare che alcuni processi intasino completamente il CPU time ed altri non riescano ad utilizzarla minimamente.
La schedulazione è un'operazione del kernel che definisce i seguenti stati di processo:
R - running, il processo è in esecuzione;
S - sleeping, il processo è in attesa (input dell'utente, conclusione di altri processi ecc..);
Z - zombie, il processo è morto ed aspetta che il parent chieda un codice d'uscita.
Ad ogni processo è associata una priorità, un valore che varia fra -20 e 19, che determina quanta CPU time rispetto agli altri il sistema gli deve dedicare.
La priorità pre-impostata di un task è 0 (-20 è considerata la priorità più alta). Solo l'amministratore puo resettare la priorità di un processo per portarla al di sotto di 0, ma i normali utenti possono variare la priorità per i valori positivi (usando il comando 'renice').
I nuovi processi ereditano la priorità dei loro padri.

JOB
La shell Unix è il tipico mezzo con cui vengono lanciati processi sul sistema (oltre ad essere essa stessa un normale processo), la shell assegna ad ogni processo lanciato da un utente un numero di job, e permette di mandare in foreground o background al sua esecuzione.

Gestione Processi

Ogni programma eseguito su un sistema è un processo, identificato con un suo PID. Quando un programma viene eseguito da una shell, assume anche un numero di job e può essere gestito all'interno della shell.

Le modalità fondamentali con cui si possono lanciare i job sono due: in foreground e in background.
Nella prima l'utente attende che l'esecuzione del suo processo termini prima di riottenere il prompt della shell.
Nella seconda invece il prompt viene restituito subito e il processo continua l'esecuzione. In questo modo l'utente può continuare a lavorare e quindi, volendo, potrebbe lanciare altri programmi in background.
Il segno & scritto alla fine del comando dice alla shell di eseguirlo in background e ridare subito il prompt.
Con CTRL-C si interrompe un processo.
Con CRTL-Z si mette in “pausa” un processo e si ritorna al prompt della shell.

La shell prevede una serie di comandi interni per gestire i job:
jobs: mostra i processi attivi in background lanciati da un certo utente. Il numero tra parentesi che viene restituito a video è il numero di, il “+” significa che è l’ultimo processo ad essere stato sospeso (fg senza parametri fa ripartire l’ultimo processo sospeso), l’altro numero è il PID.
bg: Esegue in background un processo precedentemente interrotto.
fg: Esegue un processo in primo piano.

Esistono inoltre vari comandi (file autonomi, non incorportati nella shell) utili per gestire i processi:
kill: Invia un segnale ad un processo attivo (normalmente utilizzato per fermare un processo).
nice [priority] [command]: E' un prefisso utilizzato per assegnare un certo livello di priorità al comando che si sta per eseguire. -20 vuol dire massima priorità, 19 è minima priorità.
nohup : Si può utilizzare prima di qualsiasi per evitare che il processo determinato dal comando non cada al segnale SIGHUP. E' utile quando si lavora su macchine remote e si devono eseguire comandi che possono durare a lungo. Evita l'interruzione del processo quando per problemi di rete o normale operatività ci si sconnette dalla sessione remota (via telnet o ssh). Lo standard error e tutti gli output che verrebbero stampati a schermo vengono scritti sul file nohup.out.  
ps: Visualizza un elenco dei processi in fase di esecuzione
pstree: Simile a ps ma mostra chiaramente le relazioni tra processi padre e processi figli.
top: Visualizza un elenco dei processi che sfruttano intensamente il processore e consumano molta memoria.

ps

Comando che mostra un'istantanea dei processi correnti. Le opzioni sulla riga di comando possono opzionalmente essere precedute da un '-', ma non è necessario.

ps [- ] [lujsvmaxScewhrnu ] [txx ] [O [+ |- ]k1 [[+ |- ]k2 ...]] [pids ]
m mostra informazioni sulla memoria (assieme con il flag p da il numero di pagine)
u formato utente: da il nome dell'utente e l'ora d'inizio
f le righe di comando sono mostrate in un albero
a mostra anche i processi degli altri utenti
x mostra i processi che non controllano un terminale
S aggiunge il tempo di cpu dei figli e i page fault
r solo processi running
pid Elenca solo i processi specificati; sono separati da virgole. La lista deve essere data immediatamente dopo l'ultima opzione di una riga di comando con un unico argomento, senza introdurre spazi, p.es. ps -j1,4,5
--help restituisce un messaggio d'aiuto che riassume l'uso e da un lista delle sort key supportate.
--version mostra la versione

vmstat

Comando che riporta informazioni sui processi, sulla memoria, sulla paginazione, sui block IO, i trap e l'attività della CPU.
La prima volta mostra le medie dall'ultimo reboot. Le volte successive mostra informazioni su un periodo di campionamento di lunghezza "delay". I report sui processi e la memoria sono istantanei in entrambi i casi.
Questi report sono pensati per identificare i "colli di bottiglia" del sistema. Il vmstat di Linux non si conta come processo in esecuzione.
Tutti i blocchi di Linux attualmente sono da 1k, ad eccezione per i blocchi del CD-ROM che sono da 2k.

vmstat [-n] [delay [num]]
vmstat[-V]

-n mostra l'header solo una volta invece che periodicamente.
delay è il ritardo in secondi tra gli aggiornamenti. Se non è specificato alcun ritardo, è mostrato solo un report con i valori medi dal reboot.
num è il numero degli aggiornamenti. Se non è specificato ed è definito il ritardo, allora num di default è infinito.
-V mostra informazioni sulla versione

Esempio di output

procs			memory				swap		io		system		cpu
r	b	w	swpd	free	buff	cache	si	so	bi	bo	in	cs	us	sy	id
0	0	0	0	307240	69292	66456	0	0	0	1	101	5	0	0	100

Descrizione dei campi
Procs
r: Il numero di processo in attesa del run time.
b: Il numero di processi in sleep non interrompibile.
w: Il numero di processi swap out ma altrimenti runable.
Memory
swpd: il totale della memoria virtuale usata (kB).
free: il totale della memoria libera (kB).
buff: il totale della memoria usata come buffer (kB).
Swap
si: Il totale della memoria swappata dal disco (kB/s).
so: Il totale della memoria swappata nel disco (kB/s).
IO
bi: Blocchi inviati a un device a blocchi (blocchi/s).
bo: Blocchi ricevuti da un device a blocchi (blocchi/s).
System
in: Il numero di interrupt al secondo, incluso il clock.
cs: Il numero di cambi di contesto al secondo (Contest switch).
CPU
us: Percentuale di utilizzo CPU da parte di processi in userspace
sy: Percentuale di utilizzo CPU da parte del kernel
id: Idle time

top

Comando che fornisce in tempo reale istantanee dell'attività del processore. Mostra una lista dei task del sistema che fanno un uso più intenso della CPU, e può mettere a disposizione un'interfaccia interattiva per manipolare i processi. Può ordinare i task in base all'uso della CPU, all'uso della memoria e al tempo d'esecuzione.

top [-] [d delay] [q] [c] [S] [s] [i]
d Specifica l'intervallo tra gli aggiornamenti della schermata. Lo si può cambiare con il comando interattivo s.
q Fa si che top si aggiorni senza nessun ritardo. Se il chiamante ha i privilegi del superuser, top gira alla più alta priorità possibile.
S Specifica il cumulative mode, nel quale ogni processo è mostrato con il tempo di CPU che conprende anche quello speso dai figli che sono già terminati. È come il flag -S di ps.
s Dice a top di girare in secure mode. Disabilita i pericoli potenziali dei comandi interattivi (vedere sotto).
i Avvia top ignorando qualsiasi processo idle o zombie. Si veda sotto il comando interattivo i.
c Mostra la riga di comando invece del solo nome del comando.

Descrizione dei campi
top mostra una varietà di informazioni sullo stato del processore. Di default la schermata si aggiorna ogni 5 secondi, ma questo può essere cambiato con l'opzione d in riga di comando o con il comando interattivo s.
uptime mostra da quanto tempo il sistema è "su", e i tre carichi medi del sistema. I carichi medi sono il numero medio di processi pronti per essere eseguiti durante gli ultimi 1, 5 e 15 minuti. Questa riga è come l'output di uptime . La visualizzazione dell'uptime può essere disattivata (e riattivata) con il comando interattivo l.
processes mostra il numero totale di processi in esecuzione quando è stato fatto l'ultimo aggiornamento. Questo è poi suddiviso nel numero di task che sono running, sleeping, stopped, o undead. La visulizzazione di processes e states può essere disattivata (e riattivata) con il comando interattivo t.
CPU states mostra la percentuale del tempo di CPU speso in user mode, system mode, niced task, e idle. (I niced task sono solo quelli il cui valore nice è negativo). Il tempo speso in niced task sarà contato anche in system e user time, così il totale sarà più del 100%. La visualizzazione di processes e states può essere disattivata (e riattivata) con il comando interattivo t.
Mem. Statistiche sull'uso della memoria, incluse la memoria complessiva disponibile, la memoria libera (free), la memoria condivisa (shrd), e la memoria usata per i buffer. La visualizzazione della memoria può essere disattivata (e riattivata) con il comando interattivo m.
Swap. Statistiche sulla swap, incluse lo spazio di swap totale, lo spazio di swap disponibile, e lo spazio di swap usato. Questo e Mem sono in pratica l'output di free.
PID. Il process ID di ognuno dei task.
PPID. Il parent process ID di ognuno dei task.
UID. Lo user ID del proprietario del task.
USER. Il nome utente del proprietario del task.
PRI. La priorità del task.
NI. Il valore nice del task. Valori negativi corrispondono a priorità più basse.
SIZE. Sono qui mostrati la dimensione, in Kbyte, del codice del task più i dati più lo stack.
TSIZE. La dimensione del codice del task. Da strani valori per i processi del kernel e non funziona per i processi ELF.
DSIZE. Dimensione di Data + Stack. Non funziona per i processi ELF.
TRS. Dimensione del text residente.
SWAP. Dimensione della porzione del task swappata.
D. Dimensione della pagine marcate dirty.
LIB. Dimensione delle library page usate. Non funziona per i processi ELF.
RSS. È qui mostrato l'ammontare, in Kbyte, delle memoria fisica usata del task.
SHARE. L'ammontare della memoria condivisa usata del task.
STAT. È qui mostrato lo stato del processo. Lo stato è S per sleeping, D per uninterruptible sleep, R per running, Z per zombie, oppure T per stopped o traced. Questi stati sono seguiti da < per un processo con un valore di nice negativo, da N per un processo con un valore di nice positivo, da W per un processo swappato (questo non funziona correttamente per i processi kernel).
WCHAN. A seconda dalla disponibilità di /boot/psdatabase o della kernel link map /boot/System.map mostra l'indirizzo o il nome della funzione kernel sulla quale il task è in sleep.
TIME. Il tempo di CPU totale usato dal task da quando è partito. Se è abilitato il cumulative mode, include anche il tempo di CPU usato dai suoi processi figlio che sono terminati. Il cumulative mode lo si può abilitare con l'opzione S in riga di comando oppure con il comando interattivo S. L'etichetta sulla riga di header sarà cambiata in CTIME.
%CPU. La porzione del task del tempo di CPU dall'ultimo aggiornamento della schermata, espressa come percentuale del tempo di CPU totale.
%MEM. La porzione del task della memoria fisica.
COMMAND. La riga di comando del task; sarà troncata se è troppo lunga per essere mostrata in una riga. Sarà mostrata la riga di comando completa per i task in memoria, mentre sarà mostrata solo il nome del programma fra parentesi per i task swappati (per esempio, "(getty)").

Comandi interattivi
Mentre top è in esecuzione sono riconosciuti diversi comandi "single-key". Alcuni sono disabilitati se è stata data l'opzione s in riga di comando.
^L - Cancella e riscrive la schermata.
h o ? - Mostra un schermata d'aiuto che da una breve sommario dei comandi, e lo stato dei secure e cumulative mode.
k - Killa un processo. Sarà chiesto il PID del task, e il signal da inviare. Per un kill normale, inviare il signal 15. Per un kill sicuro, ma piuttosto brutale, inviare il signal 9. Il signal di default, come per kill , è il 15, SIGTERM. Questo comando non è disponibile in secure mode.
i - Ignora i processi idle e zombie.
n o # - Cambia il numero di processi da mostrare. Sarà chiesto di inserire un numero. Ciò ignora la determinazione automatica del numero di processi da mostrare, basata sulla misura delle dimensioni della finestra. Se è specificato 0 (impostato di default), allora top mostrerà tanti processi quanti ce ne stanno sullo schermata.
q - Esce.
r - Re-nice un processo. Sarà chiesto il PID del task, e il nuovo valore del nice. L'inserimento di un valore positivo fa si che il processo sia "niced" ad un valore negativo, e perda di priorità. Se top è eseguito da root, può essere immesso un valore negativo che assegna ad un processo una priorità più alta di quella normale. Questo comando non è disponibile in secure mode.
S - Abilita il cumulative mode, l'equivalente di ps -S, cioè, i tempi di CPU comprenderanno anche i processi figlio defunct. Per alcuni programmi, come i compilatori, che lavorano con fork in molti task separati, il modo normale li fa apparire meno esigenti di quello che in realtà sono. Per gli altri, come le shell e init, questo comportamento è corretto. In ogni caso, si provi il cumulative mode per una visione alternativa dell'uso della CPU.
s - Cambia l'intervallo tra gli aggiornamenti. Sarà chiesto di inserire l'intervallo temporale, in secondi, tra gli aggiornamenti. Valori frazionari sono riconosciuti fino ai microsecondi. L'inserimento di 0 causa un aggiornamento continuo. Si noti che valori bassi causano delle schermate praticamente illeggibili, e un grosso incremento del carico. Questo comando non è disponibile in secure mode.
f o F - Aggiunge o rimuove campi da mostrare nella schermata. Si veda sotto per ulteriori informazioni.
o o O - Cambia l'ordine dei campi visualizzati. Si veda sotto per ulteriori informazioni.
l - Disabilita (riabilita) la visualizzazione delle informazioni sul carico medio e l'uptime.
m - Disabilita (riabilita) la visualizzazione delle informazioni sulla memoria.
t - Disabilita (riabilita) la visualizzazione delle informazioni sui processi e sullo stato della CPU.
c - Disabilita (riabilita) la visualizzazione del nome del comando o dell'intera riga di comando.
M - Ordina i task in base all'uso di memoria residente.
P - Ordina i task in base all'uso della CPU (default).
T - Ordina i task in base al tempo (o al tempo comulativo).
W - Scrive la configurazione corrente sul file ~/.toprc. Questo è il modo raccomandato per scrivere il file di configurazione di top.

pstree

Comando che visualizza la struttura ad albero dei processi sul sistema, e mostra anche quelli che hanno generato altri (ossia i processi "padre" e i processi "figli").

pstree [-a] [-c] [-h] [-l] [-n] [-p] [-u] [-G|-U] [pid|utente]
pstree [-V]

- a Mostra gli argomenti della riga di comando
- h Evidenzia il processo corrente e i suoi antenati
- n Ordina i processi con lo stesso antenato in base al PID
- p Mostra i PID. I PID sono mostrati in numeri decimali tra parentesi dopo ogni nome di processo. -p disabilita implicitamente la compattazione
- V Mostra la versione

kill

Comando per mandare un segnale ad un processo (non necessariamente di chiusura).

kill [ -s signal | -p ] [ -a ] pid ...
kill -l [ signal ]

pid ... Specifica la lista di processi ai quali kill deve inviare il signal. Si può scegliere fra cinque opzioni:
   n il processo con pid n viene killato (n maggiore di 0)
   0 tutti i processi nel gruppo processi corrente vengono killati
   -1 tutti i processi con pid maggiore di 1 vengono killati
   -n tutti i processi nel gruppo processi n vengono killati (n maggiore di 0)
   name tutti i processi che hanno nome name vengono killati
-s Specifica il signal da inviare. Il signal può essere dato come il nome o il numero del signal
-l Mostra una lista dei nomi dei signal
-p Specifica che kill deve solo mostrare il pid dei processi nominati, e non deve mandare loro un signal

Fermare l'output di processi in background

E' possibile fermare programmi in background che tentano di scrivere l'output su terminale.

Se eseguiamo un processo in background senza ridirezionare l'output, avremo che il testo scritto da tale processo verrà visualizzato sullo schermo senza controllo. Questo fastidioso effetto può essere eliminato tramite il seguente comando: stty tostop.
Dopo aver dato questo comando tutti i processi in background che tentano di scrivere sul  terminale saranno fermati ed eseguendo il comando jobs sulla shell apparirà il seguente messaggio:
[1] + Stopped (tty output) nomeJob
Volendo far ripartire il processo in background e vedere l'output dello stesso, è necessario portarlo in foreground tramite il comando fg. E' possibile disabilitare questa funzione tramite il con: stty -tostop.

cat /proc/$PID/cmdline

Visualizzare la stringa completa di startup di un processo non è sempre possibile.

Qualora la stringa che identifica come è stato lanciato sia troppo lunga per poterla vedere completamente con un normale comando ps, è possibile utilizzare il file system virtuale /proc, che mostra la command line che ha dato il via al processo nella variabile cmdline.

[azitti@pegasus azitti]$ ps -adef | grep mysql
root      6912     1  0 Jan28 ?        00:00:00 /bin/sh ./bin/mysqld_safe --data
mysql     6936  6912  0 Jan28 ?        00:00:00 /usr/local/mysql/bin/mysqld --de
Essendo molto lunga la stringa di startup dei processi 6912 e 6936 non sono visualizzabili completamente

[azitti@pegasus azitti]$ cat /proc/6912/cmdline
/bin/sh./bin/mysqld_safe--datadir=/usr/local/mysql/data--pid-file=/usr/local/mysql/data/pegasus.pid

[azitti@pegasus azitti]$ cat /proc/6936/cmdline
/usr/local/mysql/bin/mysqld--defaults-extra-file=/usr/local/mysql/data/my.cnf
--basedir=/usr/local/mysql--datadir=/usr/local/mysql/data--user=mysql
--pid-file=/usr/local/mysql/data/pegasus.pid--skip-locking
Nel file sytem /proc è possibile trovare le directory relative ai processi attivi nel sistema

All'interno della directory /proc/$PID (dove $PID è il PID di qualsiasi processo in esecuzione sul sistema) sono inoltre disponibili moltre altre informazioni di basso livello sul processo stesso come variabili d'ambiente, risorse occupate, link al file binario.

watch netstat -naop

Permette di controllare i processi e le connessioni attive sulla propria macchina in tempo reale.

homer@enigma:~$ sudo watch netstat -naop

Watch esegue ogni due secondi il comando netstat visualizzando: gli indirizzi in formato numerico (-n), di ogni connessione attiva (-a) inerente i protocolli tcp/udp, su quali porte, da quali indirizzi (locali o remoti), il pid e il nome del processo responsabile  (-p), ed ulteriori utili informazioni.

Notifica del cambiamento di stato di un JOB

Notificare il cambiamento dello stato di un processo che gira in background.

Normalmente l'output di un job che sta girando in background non è visibile, quindi non ci rendiamo conto dello stato in cui si trova il job. Se vogliamo che ci sia notificato immediatamente il cambiamento di stato di un job dobbiamo settare la variabile notify:

set notify (per la C shell)
set -o notify (per la bash,ksh)

Esempio:
$ set -o notify
$ sleep 10 &
$ [1]+ Done sleep 10
dopo 10 secondi viene visualizzata la notifica

Utilizzando questo comando è possibile analizzare in tempo reale l'andamento di un processo, ma in compenso l'output della nostra shell sarà "bombardata" da messaggi che possono provenire dal sistema in ogni momento. Per questo motivo la maggiorparte degli utenti preferisce lasciare il notify nello stato off. Per disabilitare il notify è possibile utilizzare: unset notify.  

ps -W | grep DIR_EXEC | grep java.exe | gawk "{print $1;}" | xargs -n1 kill -f

Belle abitudini, anche sotto Windows (grazie a Cygwin)

ps -W | grep DIR_EXEC | grep java.exe | gawk "{print $1;}" | xargs -n1 kill -f

Stringa con il fine di killare i processi java.exe lanciati entro la cartella DIR_EXEC, il tutto sotto Windows utilizzando i comandi di Cygwin.

Utilizzare nmap, netstat, ps, grep e lsof per verificare porte e servizi

E' possibile controllare il proprio computer, nel caso che qualcosa ci insospettisca o per il puro piacere di sapere cosa gira dentro la linux box.

Premetto che occorre aver installato sul proprio sistema nmap ed essere root, ed ovviamente operare da shell.

E' possibile verificare in locale quali sono i servizi attivi e le porte interessate dal traffico sia udp e tcp con il comando:
nmap 127.0.0.1 -sSU -v
l'output che seguirà sarà esteso, ma quello che ci serve, in questo caso, sono le ultime righe, con:
num.porta(TCP o UDP) stato(open/close) nome_del_servizio
a questo punto possiamo soffermarci ed analizzare determinati elementi che possono essere considerati 'sospetti' o semplicemente curiosi.

Con il comando:
ps uax | grep -i "nome_del_servizio"
possiamo vedere dei dettagli maggiori.
Un ulteriore controllo sulla rete, per verificare la connessione, con tanto di statistica in entrata ed in uscita, possiamo farlo con netstat:
netstat nav | grep -i "nome_del_servizio"

Se invece vogliamo concentrarci sul programma che eventualmente ha generato il traffico, è utilissimo il comando lsof, che elenca i file aperti:
lsof | grep -i "nome_servizio"
che ci darà in sequenza: il comando, il pid, l'user, fd, il type, il device, size ed il node name.

Windows Command-line: tskill

Permette di terminare un processo da una shell in base al ID del processo oppure al nome della sua immagine.

E' possibile utilizzare questo comando da una shell windows in modo analogo al comonado kill di Unix/Linux. E' disponibile sui sistemi multiuser.

Sintassi:
taskkill IDprocesso | NomeProcesso [parametri]
Parametri:
IDProcesso: Indica l'ID del processo da terminare;
NomeProcesso: Indica il nome del processo da terminare (puo' essere utillizzato in alternativa all'ID);
/server:NomeServer: Specifica il server terminal contenente il processo da terminare. Altrimenti, verrà utilizzato il server terminal corrente.
/id:IDSessione: Termina il processo in esecuzione in una sessione particolare;
/a: Termina il processo in esecuzione in tutte le sessioni;
/v: Modalità verbosa. Visualizza informazioni durante l'operazione;
/?: Visualizza l'help del comando;  

Un Esempio:
J:\WINDOWS\system32>tskill /V winword
Fine processo(1976)

Processi "daemon"

Nel mondo Unix a volte vengono dati nomi alle cose con una fantasia particolare.

Si definiscono DAEMON dei processi costantemente in esecuzione, che si interrompono solamente allo spegnimento della macchina per poi ripartire alla successiva riaccensione. Girano in background senza un terminale di controllo ed in genere ognuno di loro rappresenta un servizio.
Fra i più comuni, in particolare su Linux, ci sono:
apmd  Daemon di Advanced Power Management.
bootpd  Daemon Internet Boot Protocol.
fingerd  Daemon Finger.
ftpd  Daemon File Transfer Protocol.
gated  Gestisce le tabelle di routing tra reti differenti.
identd  Identifica l'utente che sta eseguendo un processo TCP/IP.
imapd  Daemon del server di posta elettronica IMAP.
inetd  Daemon per i servizi Internet.
kerneld  Fornisce servizi di caricamento automatico di moduli del kernel.
klogd  Gestisce syslogd.
lpd  Daemon per la stampante.
mountd  Server per le richieste di mount su NFS.
named  Server per i nomi di dominio Internet.
nfsd  Daemon NFS.
pop3d  Server POP3.
powerd  Monitorizza una connessione UPS.
pppd  Gestisce le connessioni di rete con protocollo punto-punto (Point to Point Protocol, in breve PPP).
rdistd  Server per la distribuzione remota di programmi.
rexecd  Server per l'esecuzione remota di programmi.
rlogind  Server rlogin.
routed  Daemon di routing.
rshd  Server di shell remota.
rwhod  Server remoto per who (rwho).
syslogd  Daemon per il logging del sistema.
talkd  Daemon di talk.
tcpd  Daemon per la rete TCP.
tftpd  Daemon Trivial File Transfer Protocol.
update  Daemon per il flush dei buffer.
ypbind  Processo NIS binder.
yppasswdd  Server per la modifica di password NIS.
ypserv  Server dei processi NIS.

nice

Comando che avvia un programma con priorità di schedulazione modificata. Se non viene specificato alcun argomento, nice mostra la priorità di schedulazione corrente. Se non è specificato nessun incremento, la priorità del comando è incrementata di 10. Il superuser può specificare anche "incrementi negativi". La priorità può essere aggiustata da nice variando tra -20 (la più alta priorità) a 19 (la più bassa).

nice [OPZIONE] [COMANDO [ARG]...]

-ADJUST  Incrementa la priorità del valore ADJUST
-n, --adjustment=ADJUST  Lo stesso di -ADJUST
--help Mostra un messaggio d'aiuto e poi esce
--version Mostra informazioni sulla versione ed esce

Software Raid su Linux

Il kernel di Linux garantisce sia la possibilità di fare raid software (su dischi IDE o SCSI) che il supporto di un gran numero di controller SCSI che permettono la gestione di raid hardware.

Il supporto RAID software del Kernel vale per Raid 0, Raid 1, Raid 4, Raid 5 e il semplice linear mode anche se varie distribuzioni come RedHat non utilizzano Raid 4 (per'altro poco usato in genere).
Nel kernel 2.4 e successivi è stato riscritto il codice e gli strumenti in userland (raidtools) per la gestione del Raid software. Tutto quello che viene riferito qui si riferisce alla nuova versione, per informazioni sulla vecchia implementazione, ancora usata su kernel 2.0 e 2.2 non patchati fare riferimento al relativo HowTo. I vecchi comandi come mdrun, mdadd, mdstop e ckraid non vengono più utilizzati.

La configurazione di RAID a livello software viene fatta tramite i metadevice /dev/md# (# è un numero progressivo, a partire da zero) che possono normalmente essere montati su delle directory del filesystem:
mount -t ext3 /dev/md0 /usr.
Il metadevice md viene trattato come un normale filesystem, che va formattato, montato e utilizzato in modo trasparente, a prescindere dai dispositivi fisici che questo utilizza.
Il file dove si configurano gli md è /etc/raidtab. Qui si definisce il nome dei metadevice virtuali che si vogliono utilizzare (/dev/md0, /dev/md1 ecc) e come questi sono composti: le partizioni fisiche che ne fanno parte (es: /dev/hda1, /dev/sda4), il tipo di Raid che va utilizzato (linear, 0, 1, 4, 5), la presenza di eventuali dischi spare di standy, che possono automaticamente essere utilizzati in caso di guasti sui dischi che fanno parte del metadevice, la dimensione delle unità "atomiche" di dati (chunk) per ogni operazione di I/O.
Possono far parte di un metadevice sia partizioni di dischi SCSI che partizioni di dischi IDE e, curiosamente, anche altri metadevice. In questo modo, per esempio, è possibile fare Raid 10 facendo un raid 1 di un device già in raid 0.
Per creare un metadevice con il livello di raid scelto su un sistema esistente con le seguenti procedure:
- Creazione di un file /etc/raidtab opportunamente e correttamente configurato
- Creazione del metadevice con il comando mkraid (Ad esempio mkraid /dev/md0 crea /dev/md0 sulla base di quanto definito in /etc/raidtab).
- Formattazione del nuovo device (mkfs.ext3 -b 4096 -R stride=8 /dev/md0) Notare che le partizioni fisiche facenti parte di md0 (specificate in /etc/raidtab) vengono cancellate, per cui non devono contenere dati utili. I parametri aggiuntivi forniti servono per specificare la dimensione dei blocchi (qui 4Kb) e il numero di blocchi per chunk (qui 8). Con questi parametri ci si aspetta un chunk-size 32 (Kb) nel file /etc/raidtab.
- Mount del device sul filesystem (es: mount -t ext3 /dev/mdo /opt)
- E' possibile verificare informazioni sul raid con cat /proc/mdstat. Consultando questo file è possibile visualizzare anche informazioni come lo stato di avanzamento di un rebuilding dei device e di fatto rimane la fonte di informazioni più diretta e chiara. Se il file manca, il proprio kernel non supporta Raid software.