Ricerca, confronto e filtri

Cercare file in un file system Unix

Su Unix esistono molteplici comandi per la ricerca di file, all'interno dell'albero delle directory. Si basano su principi diversi e si adattano a diversi usi.

find - Ricerca file contenuti nella directory indicata in base a svariati criteri, come il nome, la data di modifica, la dimensione ecc. Utile per molti scopi.
locate - Ricerca file che matchano un pattern specificato tramite un database che permette ricerche veloci e viene aggiornato col comando updatedb.
whereis - Visualizza i path di binari, sorgenti e manuali per un comando
which - Mostra la posizione di comandi eseguibili all'interno del proprio ambiente PATH.
whatis - Cerca la parola completa specificata all'interno del database whatis, contenente brevi descrizioni dei comandi del sistema. Il database viene creato con il comando makewhatis
apropos - Come whatis, ma esegue ricerche anche di parole parziali.

Utilizzare find per trovare file

Se si vuole cercare qualcosa in modo particolareggiato, senza usare locate, possiamo utilizzare find in maniera complessa.

Basta digitare da shell
find /directory/ -iname "nome_file" -exec grep -l "parola" {} \;
la /directory/ è il punto di partenza della ricerca, ovviamente al posto di "nome_file" c'è l'eventuale indicazione del file (possono essere utilizzati anche caratteri jolly come * e ?) ed al posto di "parola" c'è l'eventuale contenuto che vogliamo trovare.
Il comando sopra riportato è comodo perchè può essere utilizzato anche da utenti non-root, non sempre possibile con locate sui sistemi più 'chiusi', ovvimente la ricerca darà risultati per coloro che avranno accesso alle relative cartelle.

find

Comando estremamente utile per cercare particolari gruppi di file; funziona percorrendo l'albero delle directory a partire da ogni percorso indicato dall'argomento percorsi_di_file e rintraccia i file che soddisfano determinate condizioni. Il percorso di default è la directory corrente.
Comando comune a tutti gli Unix.

find [percorsi_di_file] [condizioni]
-print Stampa file e directory per i quali sono verificate le condizioni imposte, mostrandone il percorso completo.
-name [pattern] Trova i file i cui nomi contengono una corrispondenza con i pattern.
-iname [pattern] Versione insensibile alle maiuscole-minuscole di -name.
-type [x] Cerca file di vario tipo: b (file speciale di blocco), c (file speciale di caratteri), d (directory), p (fifo o pipe), l (link simbolico), s (socket), oppure f (file normale).
-follow Segue i link simbolici e tiene traccia delle directory visitate (non usare con -type l)
-exec [comando { } \;] Esegue il comando Unix, a partire dalla directory di partenza su ogni file per il quale find ha tracciato una corrispondenza. All'esecuzione del comando, l'argomento { } sostituisce il file corrente.
-size [n(c)] Cerca i file contenenti n blocchi, o se c è specificato, lunghi n caratteri.
-mtime [+n | -n | n] Trova tutti file che sono stati modificati più di n (+n), meno n (-n), o n giorni prima della data corrente. La modifica riguarda il cambiamento della data del file.
-atime [+n | -n | n] Trova tutti i file per i quali l'ultimo accesso risale a più di n (+n), meno di n (-n), o esattamente n giorni prima della data corrente. E' importante notare che find modifica la data/ora.
-ctime [+n | -n | n] Trova tutti i file modificati più di n (+n), meno di n (-n), o esattamente n giorni prima della data corrente.
-user [utente] Cerca i file il cui proprietario è l'utente.
-ok [comando { } \;] Come -exec, con la differenza che chiede all'utente la conferma (y) per eseguire il comando.
-path [pattern] Cerca i file i cui nomi contengono una corrispondenza con il pattern.
-ipath [pattern] Versione insensibile alle maiuscole-minuscole di -path.
-depth Processa i file contenuti in ciascuna directory prima della directory stessa. Utile se i file risiedono in directory non scrivibili.
-xdev Dice a find di non cambiare filesystem. Utile quando occore cercare qualcosa nel file system di root.
-cnewer [file] Cerca i file cambiati dopo la loro ultima modifica.
-nouser Cerca file per i quale lo userID non corrisponde ad alcun utente.
-noleaf Toglie l'ottimazione che dice "una directory contine due sotto directory in meno, da indicare del conteggio dei link". Questa azione è necessaria quando si effetuano ricerche all'interno di filesystem che non seguono le convenzioni Unix.
-newer [file] Cerca i file modificati più di recente; simile a -mtime.
-anewer [file] Cerca file per i quali si è verificato un accesso dopo l'ultima modifica.
-cnewer [file] Cerca file cambiati dopo l'ultima modifica.
-cmin [+n | -n | n] Cerca file modificati più di n (+n), meno di n (-n), o esattamente n minuti prima dell'ora corrente.
-daystart Calcola i tempi a partire dall'inizio del giorno corrente, non da 24 ore prima.

find / -name "*.log" -type f -print

Cerca in tutto il file system file o directory che terminano con .log
L'opzione -name accetta REGEXP comuni e permette ricerche molto efficaci basate sui nomi dei file.

find / -name "*.log" -type f -print
/home/al/.rhopenoffice1.1/setup.log
/etc/logrotate.d/vsftpd.log
/usr/lib/rpm/rpm.log [...]

find /var/log -type f -print | xargs grep -i [stringa]

Cerca la [stringa] (in modo case insensitive) all'interno di tutti i files presenti nella directory /var/log e in tutte le sue sottodirectory

find /var/log -type f -print | xargs grep -i [stringa]

locate

Trova un file all'interno di uno o più database di nomi di file e stampa le corrispondenze trovate.
Locate effettua la ricerca all'interno di un database che si aggiorna tramite il comando updatedb, che, tipicamente, viene schedulato per essere eseguito almeno una volta al giorno.
Un programma appena installato non può quindi essere trovato con locate fino a quando non viene eseguito updatedb e ricreato il relativo database.

locate [opzioni] [pattern]
-d [percorso] (--database=percorso) Ricerca i database nel percorso specificato.

which

Elenca il percorso completo del comando eseguibile all'interno del proprio ambiente PATH.
Comando comune a tutti gli Unix.

which [opzioni] [comando]
-a (--all) Stampa tutte le corrispondenze.
--skip-dot Salta le directory che iniziano con un punto.
-i (--read-alias) Legge gli alias dell'input standard e scrive le corrispondenze sull'output standard. Utile per usare un alias per which.
--skip alias Utile per trovare file binari normali mentre si usa --read-alias in un alias per which.

whereis

Trova i file binari, i sorgenti e le pagine di manuale relative ad un determinato comando. I nomi forniti vengono prima ripuliti del percorso e di qualsiasi estensione (in formato .ext). whereis tenta poi di localizzare il programma desiderato nelle directory standard (p.es. /bin, /etc, /usr/bin, /usr/local/bin/, ecc.)

whereis [opzioni] [file]
-b Ricerca solamente file binari.
-m Ricerca solamente le sezioni del manuale.
-s Ricerca solo i sorgenti.
-f Evidenzia con un terminatore l'ultima directory dell'elenco e segnala l'inizio dei nomi di file; inoltre deve essere utilizzata con una delle opzioni -B, -M, -S.
-B [directory] Modifica o limita il percorso nel quale whereis cerca i file binari.
-M [directory] Modifica o limita il percorso nel quale whereis cerca le sezioni di manuale.
-S [directory] Modifica o limita il percorso nel quale whereis cerca i file sorgente.

whatis

Mostra la breve descrizione di un comando cercando la parola chiave all'interno di un set di file di database whatis. Il database in questione viene rigenerato utilizzando il comando /usr/lib/makewhatis.
Simile al comando apropos, fatta eccezione che ricerca soltanto parole complete.
Equivalente a man -f.
Comando comune a tutti gli Unix.

Esempio:
[root@localhost root]# whatis ifconfig
ifconfig             (8)  - configure a network interface

apropos

Mostra una breve spiegazione di una serie di comandi che riguardano una determinata parola chiave.
Si comporta come whatis, eccetto per il fatto che ricerca una o più stringhe all'interno del set di file del database whatis (il suo argomento quindi non è il nome di un comando ma una parola generica).
Il database in questione viene rigenerato con il comando /usr/lib/makewhatis. Equivale a man -k.
Comando comune a tutti gli Unix.

Esempio:
[root@localhost root]# apropos routing
ip                   (8)  - TCP/IP interface configuration and routing utility
NETLINK_ROUTE [rtnetlink] (7)  - Linux IPv4 routing socket
netstat              (8)  - Print network connections, routing tables, interface statistics, masquerade connections, and multicast memberships
route                (8)  - show / manipulate the IP routing table
rtnetlink            (7)  - Linux IPv4 routing socket

Comandi e funzioni di filtro

Molti comandi Unix sono utilizzati come filtri per modificare il testo in input e presentarlo con l'output voluto. Vediamo alcuni dei filtri più comuni e, in genere, i comandi Unix utili per manipolare testi:

grep - Seleziona in file o nello standard input le righe di testo che contengono il pattern specificato. Es: Tutti le righe che contengono la scritta "bash".
sed - E' un flessibile e sofisticato strumento per modificare l'input secondo varie regole e match
sort - Ordina le righe del testo in input secondo criteri vari
tr - Converte o rimuove caratteri all'interno di un testo
cut - Ritaglia colonne o campi da un file, visualizzandone solo la parte selezionata
wc - Conta il numero di righe o di caratteri in un file

grep

Il comando grep permette di ricercare una determinata parola o REGEXP pattern all'interno di un file e stampa a video tutte le righe che lo matchano. E' comune in tutti gli Unix.

grep [opzioni] pattern [file]
Il file su cui operare può essere passato direttamente allo standard input di grep. Per esempio cat /var/log/maillog | grep [email protected] visualizza tutte le righe che contengono [email protected] all'interno del file maillog.
-i Ignora la distinzione tra minuscolo e maiuscolo
-l Stampa solamente i nomi dei file (una sola volta per file) che contengono righe soddisfatte dall'espressione
-n Precede ogni riga soddisfatta dall'espressione con il suo numero di riga relativo all'interno del file
-v Non vengono mostrate le righe che contengono le stringhe soddisfatte, ma le rimanenti.
-c Stampa il numero di righe per le quali è stata rintracciata una corrispondenza.
-r Legge ricorsivamente tutti i file sotto la directory indicata.
-A# Stampa # righe di testo precedenti a quella per la quale è stata trovata la corrispondenza
-B# Stampa # righe di testo successive a quella per la quale è stata trovata la corrispondenza
-C# Stampa # righe di testo precedenti e successive a quella per la quale è stata trovata la corrispondenza

sort

Il comando sort permette di ordinare le righe contenute in un file secondo criteri configurabili.
E' un comando comune in tutti gli Unix e viene tipicamente utilizzato come filtro.

sort [opzioni] [file]
-b Ignora gli spazi e i caratteri di tabulazioni all'inizio e alla fine delle righe
-c Verifica se i file sono già ordinati e, in tal caso non produce output
-f Ignora la differenza fra caratteri minuscoli e maiuscoli
-i Ignora i caratteri non stampabili
-n Effettua un ordinamento numerico
-o file Memorizza l'output nel file specificato
-r Inverte l'ordinamento
-u Le righe doppie vengono riportate in output una sola volta
-M Tratta i primi tre caratteri come sigla di mese (Jan, Feb, etc...)
-t carattere Utilizza il carattere indicato come delimitatore di campo (default è lo spazio)
+# Esegue l'ordinamento sulla base del campo #+1

wc

Questo comando stampa informazioni sul numero di caratteri, di parole e di righe dei file. Se l'argomento file non viene valorizzato, legge i dati dallo standard input. E' comune in tutti gli Unix.

wc [opzioni] [file]
-c, -bytes Stampa solamente il conteggio dei caratteri
-l, --lines Stampa solamente il conteggio delle righe
-w, --words Stampa solamente il conteggio delle parole

cut

Il comando cut è un filtro che di uno o più file in input visualizza solo le colonne, i caratteri o i campi selezionati.
E' possibile definire quale carattere viene considerato per separare campi diversi
Nell'elenco che segue considerare che list è una sequenza di interi in cui la virgola viene utilizzata per valori distinti e il trattino per intervalli di valori (es: 1,3 indica 1 e 3; 1-3 indica da 1 a 3)

cut [option] [file]
-c list Stampa solo i caratteri nella posizione definita in list
-d carattere Definisce quale carattere considerare per separare i campi in ogni riga. Va utilizzato insieme a -f
-f list Visualizza i campi identificati da list
-s Utilizzato con -f per sopprimere le righe che non contengono delimitatori

Alcuni esempi possono essere illuminanti. Prendiamo /etc/passwd.
Per visualizzare solo i nomi degli utenti e la shell impostata (campi 1 e 7, usando i : come delimitatore di campo):
[al@95 al]$ cat /etc/passwd | cut -d: -f 1,7
root:/bin/bash
bin:/sbin/nologin
[...]
mysql:/bin/bash
Per visualizzare solo i primi 5 caratteri di ogni riga:
[al@95 al]$ cat /etc/passwd | cut -c1-5
root:
bin:x
[...]
mysql

Introduzione a AWK: Tutorial

AWK è un linguaggio di programmazione che esegue azioni definibili sulla base del matching di pattern definibili.
Il suo input (un file o lo standard output di un comando) viene processato una riga alla volta e se la riga soddisfa il pattern specificato, AWK esegue l'azione specificato, scrivendo su standard output il risultato di questa azione.
E' comune in tutti gli Unix, su Linux si trova l'implementazione GNU, chiamata con la solita fantasia gawk e, come spesso accade, con una serie di funzionalità aggiunte.
In questo contesto ci limiteremo a fare alcuni esempi che possono dare un'idea delle potenzialità di awk, della logica del suo funzionamento e della sua estrema utilità in molte attività di system administration.

Le regole che awk deve seguire possono essere scritte in un file o direttamente inserite fra apici negli argomenti del comando:
awk -f file_delle_regole file_di_testo_da_processare
è analogo a:
awk 'regole' file_di_testo_da_processare
ed etrambi sono analoghi a:
cat file_di_testo_da_processare | awk -f file_delle_regole

Le regole hanno di base un formato tipo:
pattern { azione }
dove pattern indica il matchind secondo criteri vari e l'azione quello che awk genera sullo standard output per ogni riga di testo nello standard input che soddisfa il pattern stabilito.

Vediamo alcuni esempi pratici, che possono chiarire molto meglio ed iniziare ad aprirci gli occhi sul versatile mondo di awk.
Visualizzo l'output di un normale comando (ma si possono immagina le variazioni sul tema):
ls -l
total 304
-rw-r--r--    1 root     root        11142 Aug 23 18:36 config.ini
drwxr-xr-x    2 shiva    shiva        4096 Sep  3 22:25 docs/
-rw-r--r--    1 root     root         2807 Aug 23 16:49 installer.ini
-rw-r--r--    1 root     root        23264 Aug 23 16:49 license.txt
-rwxr-xr-x    1 root     root         1449 Aug 23 16:49 netscape-installer*
-rwxr-xr-x    1 root     root       249564 Aug 23 16:49 netscape-installer-bin*
-rw-r--r--    1 root     root         7995 Aug 23 16:49 README

Redireziono l'output del comando allo stdin di awk:
ls -l | awk  '{print $1}'
total
-rw-r--r--
drwxr-xr-x
-rw-r--r--
-rw-r--r--
-rwxr-xr-x
-rwxr-xr-x
-rw-r--r--
Qui non viene specificata nessuna regola di matching e per tutte le righe di input awk stampa il primo campo ($1) Di default awk considera lo spazio come carattere di separazione fra i campi di una riga e non fa distinzione (ovviamente) fra righe con sintassi, significato e formato diversi (la prima rispetto a tutte le altre).

Per stampare il nono campo di ogni riga basta sostituire $1 con $9:
ls -l | awk  '{print $9}'
config.ini
docs/
installer.ini
license.txt
netscape-installer*
netscape-installer-bin*
README
Se il nono campo non esiste, non viene stampato (della prima riga dell'ls -l originario non c'è più traccia).

Per stampare l'intera riga e non solo alcuni campi uso $0.
E se voglio iniziare a introdurre qualche regola di matching uso una simile sintassi:
ls -l | awk  '$3 == "root" {print $0}'
-rw-r--r--    1 root     root        11142 Aug 23 18:36 config.ini
-rw-r--r--    1 root     root         2807 Aug 23 16:49 installer.ini
-rw-r--r--    1 root     root        23264 Aug 23 16:49 license.txt
-rwxr-xr-x    1 root     root         1449 Aug 23 16:49 netscape-installer*
-rwxr-xr-x    1 root     root       249564 Aug 23 16:49 netscape-installer-bin*
-rw-r--r--    1 root     root         7995 Aug 23 16:49 README
In questo caso il pattern matching è piuttosto semplice: eseguo l'azione fra parentesi graffe solo per le righe in cui il terzo campo coincide con la stringa "root".

L'output di awk può essere opportunamente editato e, ovviamente, redirezionato all'input di altri comandi:
ls -l | awk  '$3 == "shiva" {print "rm -Rf " $9}' | sh
Qui, su stdout non compare nulla, ma come ci si può immaginare la directory docs/, con owner shiva, è stata rimossa. Notare che awk permette di stampare stringhe arbitrarie nelle sue azioni. Notare che lo spazio, all'interno dei doppi apici, dopo rm -Rf è necessario.

Questo è solo l'inizio, AWK è un vero e proprio linguaggio di programmazione interpretato, che presenta direttive BEGIN-END (vengono eseguite solo prima e dopo il processing dell'input), cicli IF-ELSE, variabili speciali, numerose variazioni e metodi per il matching di pattern (amggiore, minore, diverso, ecc), funzioni varie ecc.
E' molto utile per ripetere automaticamente operazioni simili secondo criteri predefinibili: di fatto esattamente quello che un sysadmin ama fare: automatizzare compiti noiosi ed evitare di digitare le quasi stesse cose per più di 3 volte di seguito.

Verifica integrità di file

Esistono diversi algoritmi che dato un input qualsiasi danno come output una stringa univoca di caratteri, di lunghezza fissa, a prescindere dalle dimensioni dell'input.
Questi algoritmi di "digesting", dal momento che anche minime differenze nell'input generano output totalmente diversi, possono essere utilizzati per verificare l'integrità di file (o messaggi di posta elettronica, o qualsiasi elemento binario o ascii).

Uno degli algoritmi più utilizzati è MD5, che crea un outout fisso (Hash) da un qualsiasi input.
Dall'output non è più possibile risalire all'input, e se lo stesso file da output diversi è stato sicuramente modificato.
IL comando per ottenere un hash MD5 da un file è md5sum e viene correntemente utilizzato per "firmare" programmi scaricabili da Internet e dare la certezza che sono versioni uguali a quelli ufficialmente rilasciate dal produttore.

Confronto di file e directory

Su Unix esistono vari comandi per confrontare file fra loro e verificare se sono diversi:
diff - Permette di fare un confronto fra il contenuto di due file di testo. Visualizza con un formato proprio le differenze e viene ampiamente utilizzato per creare delle patch di sorgenti.
diff3 - Come diff ma eseguito su 3 file.
bdiff - Come diff, ma lavora su file che possono essere divisi in più parti e quindi avere dimensioni anche molto grandi.
cmp - Compara due file ed esce con exit status diversi a seconda del risultato.
comm - Visualizza le righe diverse e quelle uguali in due file specificati.
dircmp - Compara il contenuto di 2 directory

Come sempre è possibile utilizzare vari comandi Unix comuni in script per ottenere risultati simili di confronto di file, del loro contenuto e di directory

comm

Confronta le righe comuni ai file specificati e produce un output su tre colonne:
righe presenti solo nel primo file,
righe presenti solo nel secondo file,
righe comuni a entrambi i file.
comm è simile a diff nel fatto che entrambi i comandi confrontano due file. Però comm può essere utilizzato anche come uniq; infatti comm seleziona le righe duplicate o uniche tra i due file ordinati, mentre uniq seleziona le righe duplicate o uniche all'interno del medesimo file ordinato.

comm [opzioni] file1 file2
- Legge lo standard input
-num Sopprime la stampa della colonna num. E' possibile specificare più colonne, non separate da spazi

diff

Confronta due file di testo. diff restituisce le righe differenti dei due file file1 e file2.
L'output consiste di righe di testo indicanti anche il contesto di ognuno dei due file, con il testo di file1 contrassegnato da un simbolo . Le righe di contesto sono precedute dal comando ed (a, c o d) che potrebbe essere utilizzato per convertire file1 in file2. Se uno dei due file viene indicato con -, viene letto lo standard input. Se uno dei due file è una directory, diff rintraccia il file della directory con lo stesso nome del file indicato dall'altro argomento (Es.: diff my_dir junk ha lo stesso significato di diff my_dir/junk junk). Se entrambi gli argomenti indicano directory, diff restituisce le righe che sono differenti di tutte le possibili coppie di file con lo stesso nome (Es.: oldir/program e newdir/program); inoltre diff indica tutti i nomi di file presenti solamente in una delle due directory, così come le sottodirectory comuni a entrambi. Vedere anche CMP.

diff [opzioni] [opzioni_directory] file1 file2
-a, --text Tratta tutti i file cpme file di testo. Utile per verificare se file binari sono identici
-b, --ignore-space-change Ignora le sequenze di caratteri blank ed end-of-line, trattando le prime come un unico carattere blank.
-B, --ignore-blank-lines Ignora le righe vuote nei files
-d, --minimal Per velocizzare i confronti ignora i segmenti contenenti numerosi differenze e invia in uotput solo i gruppi di differenze minime.
-H Velocizza l'output per file di grosse dimensioni ricercando solo piccole differenze; lunghe porzioni contenenti molte differenze non vengono visualizzate
-i, -- ignore-case Ignora la differenza tra caratteri minuscoli e maiuscoli durante il confronto. I caratteri minuscoli e maiuscoli sono considerati come identici
-N, --new-file Tratta i file inesistenti come file vuoti.
-q, --brief Indica solo se i file sono differenti senza mostrarne le differenze.
-r, --recursive Confronta le sottodirectory ricorsivamente
-s, --report-identical-files Indica se i file soono diversi
-S nomefile, --starting-file=nomefile Per i confronti di directory, inizia con il file nomefile, saltando i file che lo precedono nell'ordine standard di elencazione
-T, --initial-tab Inserisce caratteri tab iniziali alle righe di putput per allineare correttamente i tab
-X nomefile, --exclude-from=nomefile Non confronta i file di una directory i cui nomi corrispondono ai pattern descritti nel file nomefile.

cmp

Confronta file1 e file2. Utilizza lo standard input se file1 vale - o è mancante. Vedere anche diff. I file possono essere di qualunque tipo. Skip1 e skip2 rappresentano degli offset opzionali nei file di corrispondenza dei quali deve partire il confronto.

cmp [opzioni] file1 file2 [skip1[skip2]]
-c, --print-chars Stampa i byte differenti come caratteri
-i num, --ignore-initial=num Ignora i primi num byte dell'input.
-l, --verbose Stampa gli offset e i codici di tuttii byte differenti
-s, --quiet, --silent Lavora in silenzio, senza stampare alcun messaggio, ma restituendo i seguenti codici:
0 I file sono identici
1 I file sono differenti
2 I file sono inaccessibili
Questa opzione è utile in script, per eseguire operazioni diverse se due file sono uguali o diversi.

xargs

Applica un comando ad una lista di file ricevuta da standard input.

xargs [opzioni] [comando] [argomenti]
[comando] un comando qualsiasi del sistema, script o binario eseguibile (default /bin/echo)
[argomenti] argomenti del [comando]
-0 Interpreta lo standard input come una serie di filename separati dal "null character" (deve normalmente essere associata all'opzione "-print0" di find). Il suo utilizzo è richiesto quando i filename contengono spazi
-l num vengono passati al [comando] blocchi di "num" linee alla volta al posto del massimo consentito dalla shell
-i[stringa] ogniqualvolta appaia [stringa] in [argomenti] essa viene sostituita da una entry della lista in standard input (default "{}")

chkconfig --list | grep '3:on' | sort | awk '{ print $1 $5 }'

Permette di individuare quali servizi sono attivi al runlevel 3, quello tipicamente utilizzato su una macchina server.

Filtrando opportunamente l'output del comando chkconfig --list è possibile visualizzare informazioni formattate relative al runlevel di interesse:

[root@vagante root]# chkconfig --list | grep '3:on' | sort | awk '{ print $1 $5 }'
apmd3:on
autofs3:on
crond3:on
cups3:on
gpm3:on
iptables3:on
isdn3:on
keytable3:on
kudzu3:on
netfs3:on
network3:on
nfslock3:on
portmap3:on
random3:on
sendmail3:on
sshd3:on
syslog3:on
xinetd3:on
L'opzione --list visualizza l'elenco di tutti i servizi di sistema, tramite grep vengono filtrati sono quelli attivi (on), tramite sort vengono ordinati alfabeticamente e tramite awk vengono stampati il primo campo, contentene il nome del servizio ed il quinto, contentente il valore relativo al runlevel 3

Con poche modifiche, in particolare al parametro di grep ed al print di awk è possibile adattare questa command line a stampare i valori relativi ad altri runlevel (se avessivo voluto visualizzare i dati relativi al runlevel 5 avremmo impostato il relativo valore nel grep ed il campo $7 come secondo parametro del print di awk).