Guida ai comandi base della shell in GNU/Linux

Da Linux@P2P Forum Italia.

La Bash (Bourne Again Shell) è la più diffusa shell (linea di comando) nei sistemi GNU/Linux, è uno strumento tanto potente quanto pericoloso se usato in modo improprio. Vediamo di dare qualche indicazione sull'utilizzo dei principali comandi. Per avere una breve introduzione su cosa è una linea di comando, come accedervi e quali le principali convenzioni (fondamentali da conoscere se vogliamo usarla) fare riferimento alla guida d'introduzione all'uso della shell.


Premessa: molti comandi per essere eseguiti necessitano dei privilegi di amministratore (utente root), pertanto prima bisogna:

sudo comando
(inserire la password dell'utente che non apparirà a video neanche come asterischi!)
su
(inserire la password di root che non apparirà a video neanche come asterischi!)


Indice

Operazioni comuni

Muoversi fra le directory

Il comando cd ci permette di muoversi fra le directory, il uso utilizzo è molto semplice, volendo accedere ad una directory contenuta nella cartella in cui siamo:

cd Desktop

Volendosi spostare direttamente in una sua sottodirectory (anche infiniti livelli di sottodirectory, non c'è un limite) basta dare:

cd Desktop/emilio/amule/

Possiamo sia inserire il percorso relativo alla nostra posizione (come abbiamo fatto prima, eravano nella nostra home e siamo entrati in una directory in essa contenuta) oppure possiamo muoverci attraverso percorsi assoluti, esempio la directory Desktop, puo anche essere raggiunta così:

cd /home/ercoppa/Desktop

Ossia partendo a calcolare il percorso fin dalla / (radice di sistema)

Visualizzare il contenuto di una directory

Per visualizzare il contenuto di una directory (e non solo) utilizziamo il comando ls, l'uso più semplice è:

ls

che restiruirà il contenuto (directory, file e link) della directory in cui ci troviamo. Ma ls ci puo fornire molte più informazioni infatti associando al comando una o più delle sue opzioni (consultabili con man ls) è possibile avere molti più dettagli. Partiamo con le opzioni -al

ercoppa@gentoo ~/Desktop $ ls -al
 drwxr-xr-x  2 tizio ufficio      80 2006-01-24 14:20 sottodirectory
 -rw-r--r--  1 tizio ufficio    3655 2006-01-07 18:51 questo.txt
 -rw-rw-r--  3 tizio ufficio    5482 2005-11-15 12:41 quello.ods
 -rw-r--r--  4 caio  ufficio    1224 2005-06-27 18:15 quell'altro.jpeg
 -rwxr-x---  3 root  ufficio     458 2006-04-12 10:38 eseguibile
 lrw-rw-r--  3 tizio ufficio      19 2006-04-12 21:52 Pubblic -> /home/samba/pubblic

Analizziamo questo output (partendo da destra):

drwxr-xr-x

Il primo carattere (o meglio byte) da destra puo indicare:

Gli altri 9 caratteri che seguono, indicano i permessi assegnati su quel file rispettivamente:

I permessi per ogni soggetto (user, group, others) possono essere di tre tipi:

La presenza del segno - indica l'assenza di quel permesso

Successivamente abbiamo ad esempio

2 tizio ufficio      80 2006-01-24 14:20

L'ultima indicazione è riguardo al nome del file o della directory. Se un link simbolico, viene indicato anche la cartella o file a cui è collegato.

Pubblic -> /home/samba/pubblic

Altre opzioni interessanti per ls sono:

ercoppa@gentoo ~ $ ls -lt
totale 18652
drwxr-xr-x  5 ercoppa ercoppa    4096  6 mag 22:58 Desktop
drwxr-xr-x  9 ercoppa ercoppa    4096  6 mag 22:46 emesene
-rw-r--r--  1 ercoppa ercoppa      65  4 mag 01:54 svn
-rw-r--r--  1 ercoppa ercoppa 1150562 26 apr 18:40 prova
-rw-r--r--  1 ercoppa ercoppa  793869 25 apr 21:46 the free software song2.mp3
drwxr-xr-x 34 root    root       4096 12 apr 21:54 winex
ercoppa@gentoo ~/Desktop/amule $ ls -lR
.:
-rw-r----- 1 ercoppa ercoppa    1343614 27 mar 16:39 Manuale Del Linguaggio C.pdf
./[ebook - ITA] Manuale del Linguaggio C.zip_FILES:
totale 5692
-rw-rw-rw- 1 ercoppa ercoppa 2612224 20 set  1999 trickyc.doc
-rw------- 1 ercoppa ercoppa  679716 31 ott  2001 trickyc.doc.zip
-rw-rw-rw- 1 ercoppa ercoppa 1358512  8 mag  1999 trickyc.pdf
-rw------- 1 ercoppa ercoppa 1156807 31 ott  2001 trickyc.pdf.zip

Copiare un file

Per copiare file (comprese le directory) possiamo usare il comando cp, il suo uso più elementare è:

cp file_da_copiare destinazione

Dobbiamo subito far notare che cp non avverte in caso esists già un file con quel nome, quindi è consigliabile usare l'opzione -i che abilita la richiesta di conferma (viene posta una domanda) in caso di sovrascrittura.

ercoppa@gentoo ~ $ cp -i file_uno Desktop/
cp: sovrascrivo `Desktop/file_uno'? s

Un'altra opzione molto utile è -a, che conserva nella copia quanto è possibile della struttura e degli attributi dei file originali. Molte utile se si vogliono preservare gli stessi permessi ad esempio durante un backup di sistema.

Da tenere in considerazione è anche l'opzione -R che permette la copia ricursiva anche di tutte le sotto-directory (NOTA: -a contempla anche -R)

Spostare un file

Per spostare i file possiamo usare mv, il suo uso più elementare è:

mv file_da_spostare destinazione

La destinazione ovviamente deve essere una directory (altrimenti il file viene rinominato). Le opzioni da tenere in considerazione principalmente sono:

ercoppa@gentoo ~ $ mv -i file_uno Desktop/
mv: sovrascrivo `Desktop/file_uno'? s
ercoppa@gentoo ~ $ 
ercoppa@gentoo ~ $ mv -v  Desktop/file_uno ./
`Desktop/file_uno' -> `./file_uno'
ercoppa@gentoo ~ $

Rinominare un file

Per rinominare un file (o directory) usiamo il già noto mv, la sintassi più elementare è:

mv nome_file nuovo_nome_file

Per tutelarci dalla sovrascrittura di un file con lo stesso nome possiamo usare l'opzione -i:

ercoppa@gentoo ~ $ mv -i file_uno file_due 
mv: sovrascrivo `file_due'? s
ercoppa@gentoo ~ $

Eliminare un file

Per eliminare un file usiamo il comando rm, il suo uso più elementare è:

rm file

Nel caso in cui stessimo tentando di cancellare directory abbiamo due possibilità:

ercoppa@gentoo ~ $ rm cartella
rm: impossibile rimuovere `cartella': Is a directory
ercoppa@gentoo ~ $ rm -rf cartella
ercoppa@gentoo ~ $ rmdir cartella

Come per cp e mv è consigliabile usare un opzione di sicurezza come -i che chiede conferma per ogni file da cancellare:

ercoppa@gentoo ~ $ rm -i file_uno 
rm: rimuovere regular empty file `file_uno'? s

o nel caso di directory (non vuota):

ercoppa@gentoo ~ $ rm -rfi cartella
rm: entrare nella directory `cartella'? s
rm: rimuovere regular empty file `cartella/file_uno'? s
rm: rimuovere regular empty file `cartella/file_due'? s
rm: rimuovere directory `cartella'? s

Come per cp e mv è disponibile l'opzione -i che ci tutela dalla eliminazione dei nostri file chiedendo un ulteriore conferma alla nostra azione:

ercoppa@gentoo ~ $ rm -i processo.txt 
rm: rimuovere regular file `processo.txt'? y

Creare un link (simbolico)

Prima di capire come fare un collegamento (d'ora in poi link), bisogna fare una precisazione: in GNU/Linux (e non solo) esistono due tipologie di link:

Per creare un link simbolico dobbiamo usare il comando ln con l'opzione -s, il suo utilizzo è abbastanza semplice:

ln -s file nome_collegamento

Ecco un esempio:

ercoppa@gentoo ~ $ ln -s file_due gianni
ercoppa@gentoo ~ $ ls -l
lrwxrwxrwx  1 ercoppa ercoppa       8  8 mag 00:12 gianni -> file_due

Creare una directory

Per creare una directory usiamo il comando mkdir, il suo uso più elementare è:

mkdir nome_cartella

Montare una partizione (renderla accessibile)

Prima di tutto dobbiamo identificare la partizione, per avere delle indicazioni utili fare riferimento a questa guida. Il comando che ci permette di montare una partizione è mount, di norma è soddisfacente usarlo nella sua forma più elementare:

mount /dev/partizione /media/nome_punto_di_montaggio

Ovviamente "/media/nome_punto_di_montaggio" è una cartella (detta punto di montaggio) che abbiamo precedentemente creato con:

mkdir /media/nome_punto_di_montaggio

Vediamo le opzioni più utili da associare al comando mount:

Ecco un esempio del comando con l'opzione -t:

mount -t vfat /dev/sda1 /media/penna_usb

Ecco un esempio dell'uso di -o:

mount -o exec,async /dev/sda1 /mnt/penna_mia

Oppure combinando con l'opzione -t:

mount -o exec,async -t vfat /dev/sda1 /mnt/penna_mia

NOTA IMPORTANTE N°1: Per montare fin dall'avvio del sistema una partizione bisogna agire sul file /etc/fstab, fare riferimento alla Guida a FSTAB per questo.

NOTA IMPORTANTE N°2: Il punto di montaggio puo essere creato in qualunque punto del filesystem, comunque per convenzioni le distro sono solite montare in /media o in alternativa /mnt

Smontare una partizione

Per smontare una partizione possiamo fare in due modi:

umount /dev/sda1
umount /media/penna_mia

Capire quali partizioni sono montate

Il comando mount senza nessun altra opzione e argomento, puo fornire dettagli su quali partizioni sono montate, i relativi fs e le opzioni applicate. Quindi basterà dare:

mount

E avere un output del tipo:

/dev/hda5 on / type ext3 (rw,noatime,user_xattr)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec)
udev on /dev type tmpfs (rw,nosuid)
devpts on /dev/pts type devpts (rw,nosuid,noexec)
none on /var/tmp/portage type tmpfs (rw,size=1000)
/dev/hda3 on /mnt/ubuntu type reiserfs (rw,noexec,nosuid,nodev,user_xattr)
/dev/hda2 on /mnt/gentoo64 type xfs (rw,noatime)
shm on /dev/shm type tmpfs (rw,noexec,nosuid,nodev)
usbfs on /proc/bus/usb type usbfs (rw,noexec,nosuid,devmode=0664,devgid=85)

Leggere un file

Per leggere il contenuto di un file principalmente vengono usati tre comandi:

cat nomefile
less nomefile

Ecco alcuni tips per less (usato di default per leggere i man dei comandi):

Molto simile, ma con meno funzionalità è il comando more

tail nomefile
head nomefile

se affiancato dall opzione -N° viene incrementata la visualizzazione delle righe in base al numero scritto ad esempio:

head -15 nomefile

che visualizzera la prime 15 righe del file

Vedere i processi in esecuzione

Per vedere i processi possiamo usare il semplice ps con la sua utile opzione aux:

ps aux

che produrra la lista completa dei processi in esecuzione, con relativi dettaggi su PID (Process IDentifier), utente che che ha avviato il processo, percentuale usata, memoria usata,e altre info. Ecco uno spezzone come esempio:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
ercoppa   6492 13.3 10.8 218844 112632 ?       Sl   21:46  17:11 /opt/firefox/firefox-bin
ercoppa   6604  0.0  0.0      0     0 ?        Z    22:10   0:00 [gnome-open] <defunct>
ercoppa   6813  0.1  1.6  48264 16648 ?        Sl   22:50   0:06 gnome-terminal
ercoppa   6815  0.0  0.0   2332   708 ?        S    22:50   0:00 gnome-pty-helper
ercoppa   6816  0.0  0.1   4216  1744 pts/0    Ss   22:50   0:00 bash
ercoppa   6853  0.0  0.0      0     0 ?        Z    23:08   0:00 [play] <defunct>

Volendo avere una lista dinamica dei processi, possiamo usare il tool top, che fornirà praticamente le stesse info di ps aux (e non solo), ma aggiornate in tempo reale.

Scompattare un archivio compresso

Se si sta cercando di installare un sorgente potrebbe essere utile vedere "Come installare software in GNU/Linux"

.tar

Usiamo il comando tar con l'opzione x(extract) e vf (per avere un output delle operazioni)

tar xvf pacchetto.tar

.tar.gz e .gz

Stesso comando che per il .tar, solo con l'aggiunta di z (indica a tar che stiamo operando su .tar.gz o .gz)

tar xzvf pacchetto.tar.gz

.tar.bz2 e .bz2

Stesso comando che per il .tar, solo con l'aggiunta di j (indica a tar che stiamo operando su .tar.bz2 o .bz2)

tar xjvf pacchetto.tar.bz2

.zip

Come da logica usiamo unzip

unzip file.zip

.rar

Anche qui, il comando è abbastanza logico: unrar

unrar x file.rar

.7z

Per scompattare un file .7z, basta usare 7z:

7z x file.7z

Avere informazione sul proprio hardware (motherboard, cpu, scheda grafica, ram, chipset ecc)

Principalmente per avere informazione sul proprio hardware possiamo usare tre comandi: lspci, lsusb, lshw.

Con lspci possiamo avere informazione su i device PCI connessi, schede AGP e chipset della scheda madre (ad esempio controller SATA). Il suo uso è abbastanza elementare:

lspci

Che produrra un output del genere:

gentoo@ercoppa # lspci
00:00.0 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:00.1 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:00.2 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:00.3 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:00.4 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:00.7 Host bridge: VIA Technologies, Inc. K8T800Pro Host Bridge
00:01.0 PCI bridge: VIA Technologies, Inc. VT8237 PCI bridge [K8T800/K8T890 South]
00:07.0 FireWire (IEEE 1394): VIA Technologies, Inc. IEEE 1394 Host Controller (rev 80)
00:08.0 RAID bus controller: Promise Technology, Inc. PDC20378 (FastTrak 378/SATA 378) (rev 02)
00:0a.0 Ethernet controller: Marvell Technology Group Ltd. 88E8001 Gigabit Ethernet Controller (rev 13)
00:0e.0 Multimedia audio controller: Creative Labs SB Live! EMU10k1 (rev 0a)
00:0e.1 Input device controller: Creative Labs SB Live! Game Port (rev 0a)
00:0f.0 RAID bus controller: VIA Technologies, Inc. VIA VT6420 SATA RAID Controller (rev 80)
00:0f.1 IDE interface: VIA Technologies, Inc. VT82C586A/B/VT82C686/A/B/VT823x/A/C PIPC Bus Master IDE (rev 06)
00:10.0 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1.1 Controller (rev 81)
00:10.1 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1.1 Controller (rev 81)
00:10.2 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1.1 Controller (rev 81)
00:10.3 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1.1 Controller (rev 81)
00:10.4 USB Controller: VIA Technologies, Inc. USB 2.0 (rev 86)
00:11.0 ISA bridge: VIA Technologies, Inc. VT8237 ISA bridge [KT600/K8T800/K8T890 South]
00:11.5 Multimedia audio controller: VIA Technologies, Inc. VT8233/A/8235/8237 AC97 Audio Controller (rev 60)
00:11.6 Communication controller: VIA Technologies, Inc. AC'97 Modem Controller (rev 80)
00:18.0 Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] HyperTransport Technology Configuration
00:18.1 Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] Address Map
00:18.2 Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] DRAM Controller
00:18.3 Host bridge: Advanced Micro Devices [AMD] K8 [Athlon64/Opteron] Miscellaneous Control
01:00.0 VGA compatible controller: ATI Technologies Inc RV350 AP [Radeon 9600]
01:00.1 Display controller: ATI Technologies Inc RV350 AP [Radeon 9600] (Secondary)

In maniera analoga lsusb ci da informazione sui device USB connessi al computer. Il suo uso elementare è:

lsusb

Che produrrà un output del genere:

gentoo@ercoppa # lsusb 
Bus 002 Device 001: ID 0000:0000  
Bus 003 Device 001: ID 0000:0000  
Bus 004 Device 001: ID 0000:0000  
Bus 005 Device 001: ID 0000:0000  
Bus 001 Device 002: ID 03f0:4911 Hewlett-Packard 
Bus 001 Device 001: ID 0000:0000

Il comando che però ci fornisce più informazioni sul nostro hardware è lshw (quasi mai preinstallato nelle distro), anche lui è molto semplice da utilizzare:

lshw

Visto l'output molto lungo è consigliabile far generare un report in una pagina html e visualizzarla comodamente con un browser (nell'esempio firefox):

lshw -html > info.html && firefox info.html

Avanzate

Cambiare i permessi

Introduzione ai permessi sotto GNU/Linux

In GNU/Linux i permessi su un file possono essere di tre tipi:

E sono assegnati principalmente a tre soggetti:

Il comando per cambiare i permessi è chmod, il suo uso è molto elementare:

chmod valore file

Dove il valore dei permessi puo essere espresso in due modi:

Cambiare i permessi esprimendoli in numero ottale

Esprimere i permessi nel sistema ottale è molto semplice e diretto, una volta capita la logica che vi è dietro. Il numero che dobbiamo ricavarci è composto da tre cifre, ognuna per esprimere rispettivamente:

E ogni cifra ricaverà il valore (da 0 a 7) in base a queste regole:

Per ricavarci quindi la cifra complessiva di un soggetto (esempio il proprietario) basterà fare la somma dei valori dei permessi che vogliamo assegnargli, ad esempio se desideriamo dare il permesso di letture e scrittura, la cifrà sarà:

4 (lettura) + 2 (scrittura) = 6

Se invece vogliamo concedere il permesso di lettura e esecuzione:

4 (lettura) + 1 (esecuzione) = 5

Esempi pratici

Facciamo qualche altro esempio pratico:

ercoppa@gentoo ~ $ chmod 744 file_uno 
ercoppa@gentoo ~ $ ls -l
-rwxr--r--  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod 710 file_uno 
ercoppa@gentoo ~ $ ls -l
-rwx--x---  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod 621 file_uno 
ercoppa@gentoo ~ $ ls -l
-rw--w---x  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod 000 file_uno 
ercoppa@gentoo ~ $ ls -l
----------  1 ercoppa ercoppa       0 12 mag 21:04 file_uno

Cambiare i permessi esprimendoli in caratteri

Cambiare i permessi esprimendoli in caratteri, è molto semplice, ma meno diretto in confronto ad un valore ottale. Le regole da comprendere sono molto semplici:

Con:

I permessi ovviamente possono essere di tre tipi:

Quindi per assegnare dei permessi ai file basta usare chmod con questa sintassi

chmod soggetto=simbolotipo_di_permesso file

Dove a soggetto va sostituito u / g / o / a (o più soggetti contemporaneamente esempio: ug), poi far seguire =, il simbolo + / - a seconda se si vuole concedere o negare il permesso e infine il tipo di permesso r / w / x (o più permessi contemporaneamente, esempio rw). E' possibile anche omettere il simbolo di uguaglianza =

Esempi pratici

ercoppa@gentoo ~ $ chmod a=+w file_uno 
ercoppa@gentoo ~ $ ls -l
--w--w--w-  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod u=+rwx,go=-rwx file_uno 
ercoppa@gentoo ~ $ ls -l
-rwx------  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod u+w file_uno 
ercoppa@gentoo ~ $ ls -l
--w-------  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod a+r file_uno 
ercoppa@gentoo ~ $ ls -l
-r--r--r--  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod g+r file_uno 
ercoppa@gentoo ~ $ ls -l
----r-----  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod o+x file_uno 
ercoppa@gentoo ~ $ ls -l
---------x  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
ercoppa@gentoo ~ $ chmod ugo=+rwx file_uno 
ercoppa@gentoo ~ $ ls -l
-rwxrwxrwx  1 ercoppa ercoppa       0 12 mag 21:04 file_uno

Cambiare il proprietario di un file

Per cambiare il proprietario di un file (puo farlo solo root) basta usare chown:

chown nuovo_proprietario file

Ad esempio

gentoo@ercoppa # ls -l
-rwxrwxrwx  1 ercoppa ercoppa       0 12 mag 21:04 file_uno
gentoo@ercoppa # chown root file_uno 
gentoo@ercoppa # ls -l
-rwxrwxrwx  1 root    ercoppa       0 12 mag 21:04 file_uno

Se stiamo operando con una directory è consigliabile usare l'opzione -R, per agire ricursivamente anche sul suo contenuto:

ercoppa@gentoo ~ $ ls -l
drwxr-xr-x  2 ercoppa ercoppa    4096 13 mag 21:25 prova
ercoppa@gentoo ~ $ ls -l prova/
-rw-r--r-- 1 ercoppa ercoppa 0 13 mag 21:25 file_uno
gentoo@ercoppa # chown -R root prova
gentoo@ercoppa # ls -l
drwxr-xr-x  2 root    ercoppa    4096 13 mag 21:25 prova
gentoo@ercoppa # ls -l prova/
-rw-r--r-- 1 root ercoppa 0 13 mag 21:25 file_uno

Cambiare il gruppo di appartenza di un file

Per cambiare il gruppo proprietario di un file usiamo chgrp, il suo uso è molto semplice:

chgrp gruppo file

UN opzione interessante è -R, che come logico aspettarsi, cambia il gruppo proprietario ricursivamente per tutti i file contenuti in una directory:

chgrp -R gruppo cartella

Ecco qualche esempio:

ercoppa@gentoo ~ $ ls -l
drwxr-xr-x  2 ercoppa ercoppa    4096 21 mag 18:08 prova
ercoppa@gentoo ~ $ ls -l prova/
-rw-r--r-- 1 ercoppa ercoppa 0 21 mag 18:08 file_uno
gentoo@ercoppa # chgrp -R root prova
gentoo@ercoppa # ls -l
drwxr-xr-x  2 ercoppa root       4096 21 mag 18:08 prova
gentoo@ercoppa # ls -l prova/
-rw-r--r-- 1 ercoppa root 0 21 mag 18:08 file_uno

Uccidere (killare) un processo

Per terminare un processo usiamo kill fornendo come indicazione sul processo il PID (Process IDentifier), facilmente ricavabile osservando output di top o ps aux. Il suo uso è semplice

kill PID

Esempio pratico:

kill 5926

Un opzione per forzare l'uccisione di un processo, nel caso questo non rispondesse al classico segnale, è -9:

kill -9 PID

Esempio pratico

kill -9 5926

Caricare un modulo del kernel

Per caricare un modulo del nostro kernel possiamo usare modprobe:

modprobe nome_modulo

Se vogliamo avere una lista dei moduli già caricati usiamo lsmod:

ercoppa@gentoo ~ $ lsmod
Module                  Size  Used by
nfnetlink_queue         8512  1 
nfnetlink               5016  2 nfnetlink_queue
xt_tcpudp               2752  4 
xt_multiport            3136  2 
iptable_filter          2368  1 
ip_tables               9800  1 iptable_filter
xt_state                1856  3 
ip_conntrack           37868  1 xt_state
xt_NFQUEUE              1792  3 
x_tables               11268  5 xt_tcpudp,xt_multiport,ip_tables,xt_state,xt_NFQUEUE

Per avere una lista completa dei moduli compilati nel nostro kernel ,che è possibile caricare con modprobe, possiamo usare quest'ultimo con l'opzione -l (elle):

gentoo@ercoppa # modprobe -l
/lib/modules/2.6.19-gentoo-r5/alsa-driver/synth/snd-util-mem.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/synth/emux/snd-emux-synth.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/pci/ac97/snd-ac97-codec.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/pci/ac97/snd-ac97-bus.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/pci/emu10k1/snd-emu10k1.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/pci/emu10k1/snd-emu10k1-synth.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/misc/ac97_bus.ko
/lib/modules/2.6.19-gentoo-r5/alsa-driver/acore/snd-rawmidi.ko
/lib/modules/2.6.19-gentoo-r5/misc/vboxdrv.ko
/lib/modules/2.6.19-gentoo-r5/x11-drm/radeon.ko
/lib/modules/2.6.19-gentoo-r5/x11-drm/drm.ko

Per ricavare il nome del modulo basterà quindi togliere il percorso del file (nel nostro caso /lib/modules/2.6.19-gentoo-r5/cartella/) e non considerare l'estensione (.ko), esempio:

gentoo@ercoppa # modprobe drm

Visualizzare informazioni su un modulo

per avere qualche informazione in piu' sui moduli compilati nel kernel usiamo modinfo:

cydonia@cydonia ~$ modinfo drm
filename:       /lib/modules/2.6.20-16-386/kernel/drivers/char/drm/drm.ko
license:        GPL and additional rights
description:    DRM shared core routines
author:         Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl
srcversion:     1B6FCEBBDA6FEECCBD70ADC
depends:        agpgart
vermagic:       2.6.20-16-386 mod_unload 486 
parm:           cards_limit:Maximum number of graphics cards (int)
parm:           debug:Enable debug output (int)

Creare un utente

Per creare un nuovo utente nel nostro sistema usiamo useradd, vediamo come usarlo accompagnato dalle opzioni piu utili:

useradd nome_nuovo_utente -m -G gruppo1,gruppo2,gruppo3 -s /bin/bash

Analizziamo subito le opzioni usate:

Altre opzioni utili sono:

Per assegnare una password all'utente (necessaria per il login) vedere la sezione più sotto

Eliminare un utente

Per eliminare un utente dal nostro sistema possiamo usare il comando userdel, l'uso più semplice è:

userdel utente

Nel caso in cui volessimo cancellare anche la sua cartella sotto /home, aggiungiamo l'opzione -r

userdel -r utente

Aggiungere o rimuovere un utente ad un gruppo

Per aggiungere un utente al gruppo usiamo gpasswd, con l'opzione -a in questo modo

gpasswd -a nomeutente gruppo

In modo analogo per rimuovere un utente da un gruppo usiamo l'opzione -d operando nel seguente modo

gpasswd -d utente gruppo

Cambiare password ad un utente

Il modo più semplice per cambiare la password di un utente è con passwd:

passwd utente

Oppure se sta cambiando la proprio password si puo omettere l'utente

passwd

Redirigere l'output di un comando

Prima di tutto bisogna fare una premessa concettuale

Standard input, output ed error

Ad ogni processo GNU/Linux assegna implicitamente tre "descrittori" ("file descriptor":)

Con la Bash possiamo facilmente "gestire" e monovrare questo flusso di dati secondo le nostre esigenze.

Redirigere l'output

Per redirigere l'output di un processo possiamo usare >. Un esempio classico dell'uso è quando vogliamo redirigere l'ouput di un comando su un file di testo:

ercoppa@gentoo ~ $ ps aux > processo.txt

In questo caso ho inviato il risultato del comando ps aux al file processo.txt (che potrò leggere con tutta comodità in un secondo momento).

Concatenare più comandi con | , && e ;

Il carattere | (premere shit+\ per produrlo) puo essere definito come un condotto (pipeline) che permette di incanalare lo standard output del comando che lo precede, nello standard input del comando che lo segue. Maggiori info qui paragrafo "139.3.2 Condotto"

comando1 | comando2

All'atto pratico l'output del comando1 verrò "processato/elaborato" dal comando2. Vediamo un esempio molto banale:

gentoo ercoppa # lsusb
Bus 004 Device 001: ID 0000:0000  
Bus 005 Device 001: ID 0000:0000  
Bus 003 Device 001: ID 0000:0000  
Bus 002 Device 001: ID 0000:0000  
Bus 001 Device 002: ID 03f0:4911 Hewlett-Packard 
Bus 001 Device 001: ID 0000:0000  
gentoo ercoppa # lsusb | grep "Packard"
Bus 001 Device 002: ID 03f0:4911 Hewlett-Packard

Come possiamo vedere l'output di lsusb (che ha il compito di fornire informazioni sui device usb connessi al computer) viene elaborato da grep

La sequenza && permette di far eseguire più comandi alla shell nell'ordine da noi specificato:

comando1 && comando2

Il comando2 viene eseguito solo, e solo se, il comando1 viene terminato/eseguito positivamente (exit code 0). Facciamo qualche breve esempio:

ercoppa@gentoo ~ $ echo ciao && echo pino
ciao
pino

In questo caso, il primo comando (echo stampa a schermo semplicente l'argomento fornito) viene eseguito senza problemi e pertanto la bash esegue anche il secondo comando. Vediamo un esempio negativo:

ercoppa@gentoo ~ $ cd ... && echo fatto
bash: cd: ...: No such file or directory

La bash non puo andare in ... perchè non esiste una tale directory, pertanto il secondo comando non viene eseguito.

Il carattere ";" permette di concatenare quanti comandi si vuole: la shell tenterà di eseguire il comando seguente solo dopo che il precedente sia stato portato a termine ed indipendentemente dall'esito di quest'ultimo; il codice di uscita della sequenza sarà quello dell'ultimo comando eseguito. La sintassi é questa:

comando1; comando2

esempio:

ercoppa@gentoo ~ $ cd ...; echo fatto
bash: cd: ...: No such file or directory
fatto

Possiamo vedere che il secondo comando viene avviato nonostante il fallimento del primo.

Manipolare l'output di un comando con grep e tail

Un comando molto utile è grep, il suo compito è quello di stampare le linee in cui compaia una certa stringa, per comprenderlo meglio passiamo subito ad un esempio:

ercoppa@gentoo ~ $ cat ciao.txt 
ciao1
ciao2
ciao3
ciao1 ciao2
ercoppa@gentoo ~ $ cat ciao.txt | grep ciao2
ciao2
ciao1 ciao2

Come potete vedere il file ciao.txt contiene varie linee, ma grazie a grep possiamo estrapolare dal nostro file solo le linee che contengono quella specifica stringa. Il comando grep è fondatamentale quando stiamo cercando qualcosa in file molto grossi come un log:

ercoppa@gentoo ~ $ dmesg | grep hda
Kernel command line: root=/dev/hda5 1
ide0: BM-DMA at 0xfc00-0xfc07, BIOS settings: hda:DMA, hdb:pio
hda: Maxtor 6B200P0, ATA DISK drive
hda: max request size: 512KiB
hda: 398297088 sectors (203928 MB) w/8192KiB Cache, CHS=24792/255/63, UDMA(133)
hda: cache flushes supported
hda: hda1 hda2 hda3 hda4 < hda5 hda6 >
EXT3-fs: hda5: orphan cleanup on readonly fs
EXT3-fs: hda5: 1 orphan inode deleted
EXT3 FS on hda5, internal journal
ReiserFS: hda3: found reiserfs format "3.6" with standard journal
ReiserFS: hda3: using ordered data mode
ReiserFS: hda3: journal params: device hda3, size 8192, journal first block 18, max trans len 1024, max batch 900,   
ReiserFS: hda3: checking transaction log (hda3)
ReiserFS: hda3: Using r5 hash to sort names
XFS mounting filesystem hda2
Ending clean XFS mount for filesystem: hda2
Adding 1647292k swap on /dev/hda6.  Priority:-1 extents:1 across:1647292k

Come è possibile vedere ho facilmente estrapolato tutti i riferimenti a hda (un disco IDE) dentro a dmesg.

A questo punto é bene soffermarsi un attimo per puntualizzare alcuni problemi in cui prima o poi incorrerà con grep (e non solo) l'utente alle prime armi. Creiamo un file di testo che chiamiamo testo.txt con due righe; "3.4" la prima, "3A4" la seconda:

$ echo -e "3.4\n3A4" > testo.txt
$ cat testo.txt
3.4
3A4

Se ora diamo grep per selezionare la riga contenente l'epressione "3.4" come abbiamo fatto finora, otterremo questo output:

$ grep 3.4 testo.txt
3.4
3A4

Vediamo che non é stata selezionata la sola riga prevista. La ragione di questo fatto é che grep fa uso di un sistema di modelli chiamato "espressioni regolari" (spesso abbreviato in "RegExp" od altro, dall'inglese "Regular Expressions"). In questo tipo di modelli alcuni caratteri sono "interpretabili", cioé il comando può sostituire ad esso altri caratteri. Il carattere punto (".") del nostro esempio, in questo contesto, può essere sotituito da un altro qualsivoglia singolo carattere (oltre che da se stesso), ad esempio anche da "A"; quindi la striga "3A4" sarà ritenuta valida da grep. Per ovviare a questo inconveniente, il sistema delle espressioni regolari ammette dei caratteri detti di "fuga" ("escape", in inglese) che servono a dire al comando che uno o più caratteri interpretabili devono essere considerati nel loro significato letterale. Uno di questi é la controbarra ("\", "backslash" in inglese) che impone il significato appunto letterale al singolo carattere successivo. Proviamo, dunque, ad anteporre "\" alla nostra espressione:

$ grep 3\.4 testo.txt
3.4
3A4

Che dire: benvenuti nel mondo Unix! Naturalmente c'é una ragione al fatto che otteniamo lo stesso precedente output: la backslash é un carattere di escape anche per bash (mentre il punto ha solo il suo valore letterale). Bash, prima di avviare un comando effettua una quantità di operazioni, tra le quali la risoluzione dei caratteri di escape per lui validi; una volta risolta la controbarra, restituirà a grep l'espressione "3.4" e, quindi, grep interpreterà a sua volta il carattere ".", ormai non più protetto, esattamente come nel caso precedente. Per nostra fortuna bash effettua tale operazione una sola volta, questo significa che potremo proteggere da interpretazioni, questa volta di bash, anche il nostro stesso carattere di escape:

$ grep 3\\.4 testo.txt
3.4

Bash risolverà la prima controbarra restituendo a grep la striga "3\.4" che ora sarà interpretata come vogliamo. Va detto che la soluzione vista, seppure efficace, non viene generalmente utilizzata, in quanto con espressioni più complesse si rischia la confusione di controbarre. Siccome, ad esempio, bash evita di interpretare il carattere "\" (oltre ad alcuni altri) nelle stringhe delimitate da ", possiamo ricorrere a quest'ultimo:

$ grep "3\.4" testo.txt
3.4

che dovrebbe apparire più chiaro. Questa é la ragione per cui sarebbe bene abituarsi a delimitare sempre con " le espressioni per grep. Un'altra possibilità é di utilizzare l'opzione "--fixed-strings" di grep che evita l'interpretazione dei caratteri dell'intera stringa:

$ grep --fixed-strings 3.4 testo.txt
3.4

Esistono parecchie altre fantasie sul tema.

Anche tail ci puo aiutare in molte situazioni, il suo scopo è quello di mostrare solo l'ultima parte (di default 10 linee) di un output. Ecco un esempio:

ercoppa@gentoo ~ $ dmesg | tail
mtrr: 0xd0000000,0x10000000 overlaps existing 0xd0000000,0x1000000
mtrr: 0xd0000000,0x10000000 overlaps existing 0xd0000000,0x1000000
mtrr: 0xd0000000,0x10000000 overlaps existing 0xd0000000,0x1000000
mtrr: 0xd0000000,0x10000000 overlaps existing 0xd0000000,0x1000000
agpgart: Found an AGP 3.0 compliant device at 0000:00:00.0.
agpgart: Putting AGP V3 device at 0000:00:00.0 into 4x mode
agpgart: Putting AGP V3 device at 0000:01:00.0 into 4x mode
[drm] Setting GART location based on new memory map
[drm] Loading R300 Microcode
[drm] writeback test succeeded in 1 usecs

E' possibile specificare la "quantita" di un file da mostrare sia in linee che in bytes, per info su come usare a fondo tail consultare il man con man tail

Mandare in background un processo (e recuperarlo)

Per mandare in background un processo usiamo il carattere &, in questo modo

comando &

Ecco un esempio

ercoppa@gentoo ~ $ mioscript &
[1] 3924
ercoppa@gentoo ~ $

Faccio notare che viene fornito il numero di job (in questo caso 1).A questo punto il comando puo essere "recuperato" in foreground con il comando fg

fg %n

Dove n è il numero di job, quindi nel nostro esempio ci basta fare

fg %1

Per ritrovarci di nuovo lo script in "primo piano".

Un altro sistema per poter mandare in background un processo: mandiamo in esecuzione un processo

ercoppa@gentoo ~ $ ./mio_script

Premiamo Ctrl+z in modo tale da fermare (ma non terminare) il processo ed ottenere:

[1]+  Stopped                 mio_script

E poter mandare in background il processo attraverso in numero di job

ercoppa@gentoo ~ $ bg %1
[1]+ mio_script &

e semmai recuperarlo con

ercoppa@gentoo ~ $ fg %1

Creare un archivio compresso

tar

tar -cf nome.tar cartella_comprimere/

tar.gz

tar -czf nome.tar.gz cartella_comprimere/

tar.bz2

tar -cjf nome.tar.bz2 cartella_comprimere/

zip

zip -r nome.zip cartella_comprimere/

rar

rar a nome.rar cartella_comprimere

Dubbi? leggi il manuale

man

La prima fonte che dobbiamo consultare in caso di dubbi su un comando è il man di quest'ultimo: con buona probabilità è la documentazione più completa e aggiornata che si possa trovare in giro e, anche se in inglese, è scritta nel modo più comprendibile possibile. Per visualizzare il manuale di un comando usiamo man seguito dal comando:

man comando

Vediamone un esempio:

man mkdir

L'output che riceviamo è (ad oggi) così:

MKDIR(Novembre 1998)                                                                        MKDIR(Novembre 1998)



NOME
      mkdir - crea directory

SINTASSI
      mkdir [opzioni] directory...

      Opzioni POSIX: [-p] [-m mode] [--]

      Opzioni GNU (forma breve): [-p] [-m modo] [--verbose] [--help] [--version] [--]

DESCRIZIONE
      mkdir crea directory con i nomi specificati.

      Di natura, i permessi delle directory create sono 0777 (<<a+rwx>>) meno i bit impostati nella umask.


OPZIONI
      -m modo, --mode=modo
             Imposta  a  modo  i  permessi, che possono essere simbolici come in chmod(1), e poi usa i permessi
             predefiniti come punto di partenza.

      -p, --parents
             Crea ogni directory genitrice mancante per ogni argomento directory .  I permessi delle  directory
             genitrici  sono  impostati  al  valore di umask modificato con  u+wx.    Ignora gli argomenti cor-
             rispondenti a directory esistenti (per cui, se una directory /a esiste  gia,  <<mkdir  /a>>  e  un
             errore, mentre <<mkdir -p /a>> non lo e).

      --verbose
             Visualizza un messaggio per ogni directory creata. Cio e utile soprattutto con --parents.

      --     Termina l'elenco delle opzioni.

OPZIONI GNU STANDARD
      --help Stampa un messaggio di spiegazione sullo standard output ed esce (con successo).

      --version
             Stampa informazioni sulla versione sullo standard output ed esce (con successo).

      --     Termina l'elenco delle opzioni.

AMBIENTE
      Le variabili  LANG, LC_ALL, LC_CTYPE e LC_MESSAGES hanno il solito significato.

CONFORME A
      POSIX.2

NOTE
      Questa  pagina  descrive  mkdir come si trova nel pacchetto fileutils-4.0; altre versioni potrebbero dif-
      ferire leggermente.



                                               GNU fileutils 4.0                           MKDIR(Novembre 1998)

Analizziamo le vari parti:

Per i comandi più comuni e/o complessi potrebbero essere presenti nel man numerosi esempi pratici sull'uso delle opzioni.

comando --help

Per avere un sunto, semplice e ben fatto, di tutte le opzioni (e non solo) che il comando contempla possiamo usare l'opzione (che ogni comando dovrebbe avere) --help (o a volte -h):

comando --help

Vediamone un esempio:

ercoppa@gentoo ~ $ mkdir --help
Uso: mkdir [OPZIONE]... DIRECTORY...
Crea la/le DIRECTORY, se non esistono già.

Mandatory arguments to long options are mandatory for short options too.
  -m, --mode=MODE   set file mode (as in chmod), not a=rwx - umask
  -p, --parents     no error if existing, make parent directories as needed
  -v, --verbose     print a message for each created directory
      --help     display this help and exit
      --version  stampa le informazioni sulla versione ed esce

Report bugs to <bug-coreutils@gnu.org>.

Come possiamo vedere in poche righe è riassunto tutto il man (o almeno la parte più utile) semplice da essere consultate, anche per i meno esperti


help comando

Bash é dotata di un insieme di comandi interni detti "builtin". Alcuni di essi hanno lo stesso nome di comandi i cui eseguibili si possono trovare in /bin o in /usr/bin, hanno la stessa funzione e vengono di norma avviati in luogo di questi. Per quanto riguarda l'uso elementare dei comandi interni, la loro sintassi non si discosta da quella dei corrispondenti esterni, mentre ci possono essere differenze quando si utilizzano opzioni più ricercate. Per visualizzare le caratteristiche di un comando interno si deve consultare la pagina "man" di bash, oppure si può utilizzare il comando "help" "builtin" di bash con la sintassi help comando. Esempio:

$ help echo
echo: echo [-neE] [arg ...]
   Output the ARGs.  If -n is specified, the trailing newline is
   suppressed.  If the -e option is given, interpretation of the
   following backslash-escaped characters is turned on:
   	\a	alert (bell)
   	\b	backspace
   	\c	suppress trailing newline
   	\E	escape character
   	\f	form feed
   	\n	new line
   	\r	carriage return
   	\t	horizontal tab
   	\v	vertical tab
   	\\	backslash
   	\num	the character whose ASCII code is NUM (octal).
   
   You can explicitly turn off the interpretation of the above characters
   with the -E option.

Alcune distribuzioni hanno una specifica pagina "man" dedicata ai comandi interni.

Approfondimenti

Strumenti personali
Namespace
Varianti
Azioni
Navigazione
CollectionTricks
Siti amici
Strumenti