Salta il menu
*Linux Guide

I Comandi

E' ora giunto il momento di affrontare approfonditamente la questione della famigerata "Linea di comando", è giunto il momento di farlo ricordando innanzitutto le funzioni della Linea di Comando.
Quando clicchiamo su un pulsante della barra degli strumenti di un qualsiasi programma, impartiamo un ordine al sistema in modo che ne derivi una risposta precisa e prevedibile. Quando clicchiamo sul pulsante "Salva", il programma avvia un processo tale per cui il file prodotto viene registrato e conservato in una cartella particolare a cui potremo risalire nel momento del bisogno. In genere il cliccare sul pulsante ci determina la negazione conoscitiva per cui non ci interessa di sapere come sia potuto accadere il meccanismo di salvataggio.
L'interfaccia grafica dei programmi moderni si fonda su azioni effettuate con il puntatore del mouse. Prima dell'avvento delle interfacce grafiche le azioni venivano ottenute attraverso la digitazione di comandi testuali effettuata in una finestra di prompt che si chiama Shell. In essa si dovevano digitare ordini specifici per ottenere risposte specifiche e rapidissime. Questo imponeva la perfetta conoscenza della sintassi e delle regole di impartizione degli ordini e non tutti erano in grado di farlo. Il vantaggio era quello di avere un sistema efficientissimo, potentissimo, rapidissmo.
L'avvento delle interfacce grafiche ha diffuso l'uso del computer in modo vertiginoso ed è impossibile oggi ipotizzare sistemi operativi privi di veste grafica, tuttavia queste vesti grafiche hanno un peso ed un ingombro gigantesco, tali per cui il computer deve praticamente sopportare un carico di lavoro immenso per fare cose che, da linea di comando, sarebbero uno scherzetto.
Nel mondo Windows l'uso dell'interfaccia grafica è un dovere, un comandamento, al punto che i computer di appena una generazione tecnologica precedente, hanno difficoltà gravi nel soddisfare le esigenze di programmi esosi e graficamente superflui. Nel mondo Linux le cose sono invece diverse. Non si è ritenuto fondamentale l'uso della grafica, quanto invece la ottimizzazone d'impiego per cui l'uso della linea di comando è ancora una soluzione praticata per avere prestazioni che in altri sistemi sono irraggiungibili.
Non va inoltre dimenticato che l'uso della linea di comando e l'uso dei comandi digitati, sono soluzioni senza tempo e senza vincoli legati alle interfacce grafiche. Anche se il programma riceve una evoluzione prestazionale, i comandi saranno sempre impartiti nello stesso modo, cosa che non si può dire con i programmi ad interfaccia grafica. In essi infatti le cose possono cambiare solo per il semplice fatto che è cambiata l'interfaccia grafica dello stesso programma che fa sempre le stesse cose.
Questa condizione è la gioia e il cruccio di tutti gli utenti Linux e soprattutto di quelli che vorrebbero usare Linux. Non è facile usare la linea di comando; richiede impegno, tempo, informazione, lettura e pazienza, ma in alcune condizioni è l'unica soluzione, come nello scaricamento e installazione di nuovi programmi.

*Per aprire la Shell e usare i comandi, basta cliccare sull'icona del terminale posta solitamente nel menu principale. In un batter d'occhio si apre una finestra molto semplice, quasi spoglia, con una striminzita riga di testo con indicato il nome dell'utente e l'hostname (nome del computer), per definizione la shell parte dalla directory /home dell'albero delle directory :user@hostname:~$
Il terminale è quindi in grado di ricevere uno o più ordini. Il simbolo $ indica il prompt della shell ovvero l'attesa di un comando.
Vediamo ora alcuni dei comandi semplici con i quali usare la shell e rendersi conto dela sua potenza.

Premessa

Molti comandi per essere eseguiti necessitano dei privileggi di amministratore (utente root).
In Ubuntu/Kubuntu/Xubuntu occorre anteporre ai comandi sudo, come sotto:

sudo comando

Va quindi immessa la password di root.
In una qualsiasi altra distro occorre loggarsi come root

su

quindi va digitata la password di root.

Operazioni comuni

Muoversi fra le directory

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

cd Desktop

Volendosi spostare direttamente in una sua sottodirectory (anche infiniti livelli di sottodirectory) basta digitare:

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/pinco/Desktop

Ossia considerando il percorso fin dalla / (radice di sistema).

Visualizzare il contenuto di una directory

Per visualizzare il contenuto di una directory utilizzare il comando ls il cui 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

pinco@linux ~/Desktop $ ls -al
drwx r-x r-x 2 pinco webdesigner 80 2009-01-24 14:20 sottodirectory
-rw-r--r-- 1 pinco webdesigner 3655 2009-01-07 18:51 testo.txt
-rw-rw-r-- 3 pinco webdesigner 5482 2008-11-15 12:41 file.ods
-rw-r--r-- 4 pinco webdesigner 1224 2008-06-27 18:15 immagine.jpeg
-rwxr-x--- 3 pinco webdesigner 458 2009-04-12 10:38 eseguibile
-rw-rw-r-- 3 sempronio webdesigner 19 2009-04-12 21:52 filmato.mpeg

Analizziamo questo output (partendo da destra):

drwx r-x r-x

Il primo carattere (o meglio byte) da destra puo indicare:
  • d ossia che è una directory
  • - ossia che è un file
  • l ossia che link (simbolico)
  • b per un dispositivo speciale a blocchi
  • c per un dispositivo speciale a caratteri
  • p per un FIFO
  • s per un socket

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

  • i primi tre (dopo la 'd') indicano i permessi dell'utente proprietario (user) di quel file
  • i successivi tre (r-x) indicano i permessi assegnati al gruppo (group) (ossia tutti gli utenti appartenenti a quel gruppo)
  • gli ultimi 3 caratteri (r-x) indicano i permessi assegnati a tutti gli altri utenti (others)
I permessi per ogni soggetto (user, group, others) possono essere di tre tipi:
  • r (reading) per la lettura (in caso di directory è possibile vedere la lista dei files contenuti)
  • w (writing) per la modifica (o eliminazione)
  • x (executing) per indicare il permesso di eseguire il file
La presenza del segno '-' indica l'assenza di quel permesso

Successivamente abbiamo ad esempio

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

  • 2 rappresenta il numero di collegamenti (link) verso quel file
  • pinco è il proprietario (user) del file
  • webdesigner è il gruppo a cui appartiene il file
  • 80 la dimensione in byte
  • 2009-01-24 è la data (e eventualmente anche l'ora) di creazione o ultima modifica del file

Altre opzioni interessanti per ls sono:

  • -lt che mostra secondo la data di ultima modifica (dal più recente al più vecchio):

    pinco@linux ~ $ ls -lt
    totale 18652
    drwxr-xr-x 5 pinco pinco 4096 6 mag 22:58 Desktop
    drwxr-xr-x 9 pinco pinco 4096 6 mag 22:46 emesene
    -rw-r--r-- 1 pinco pinco 65 4 mag 01:54 svn
    -rw-r--r-- 1 pinco pinco 1150562 26 apr 18:40 prova
    -rw-r--r-- 1 pinco pinco 793869 25 apr 21:46 the free software song2.mp3
    drwxr-xr-x 34 root root 4096 12 apr 21:54 winex

  • -lR che elenca ricorsivamente tutte le sottodirectory incontrate:

    pinco@linux ~/Desktop/amule $ ls -lR
    -rw-r----- 1 pinco pinco 1343614 20 ago 16:39 Guida Ubuntu.pdf
    ./Linux/Ubuntu Inside/Guida Ubuntu:
    totale 5692
    -rwxr-xr-x 1 pinco pinco 5283 23 nov 19:00 guida-ubuntu-print.css
    -rwxr-xr-x 1 pinco pinco 5522 5 dic 13:57 guida-ubuntu-style.css

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 esiste 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.

pinco@linux ~ $ cp -i file_uno Desktop/
cp: sovrascrivo `Desktop/file_uno'? s

Un'altra opzione molte 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ù elemntare è:

mv file_da_spostare destinazione

La destinazione ovviamente deve essere una directory (se no il file viene rinominato). Le opzioni da tenere in considerazione sono:
  • -i: chiede una conferma per la sovrascrittura nel caso in cui nella destinazione da noi specificata esista già un file (o directory) con quel nome, vediamo un esempio pratico:

    pinco@linux ~ $ mv -i mio_file Desktop/
    mv: sovrascrivo `Desktop/mio_file'? s
    pinco@linux ~ $

  • -v: stampa il nome di ogni file prima di spostarlo

    pinco@linux ~ $ mv -v Desktop/mio_file ./
    `Desktop/mio_file' -> `./mio_file'
    pinco@linux ~ $

Rinominare un file

Per rinominare un file (o directory) usiamo 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:

pinco@linux ~ $ mv -i file_uno file_due
mv: sovrascrivo `file_due'? s
pinco@linux ~ $

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à:
  • usare rm con le opzioni -rf:

    pinco@linux ~ $ rm cartella
    rm: impossibile rimuovere `cartella': Is a directory
    pinco@linux ~ $ rm -rf cartella

  • se la directory è vuota, usare rmdir

    pinco@linux ~ $ rmdir cartella

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

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

o nel caso di directory (non vuota):

pinco@linux ~ $ 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

Creare un link (simbolico)

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

  • simbolico (soft link): è quello che siamo soliti incontrare anche in ambiente windows ed è quello che continueremo ad usare, salvo specifiche necessità.
  • hard link: è qualcosa di più complesso, che lega il link al contenuto stesso (inode) del file collegato.
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:

pinco@linux ~ $ ln -s file_due giorgio
pinco@linux ~ $ ls -l
lrwxrwxrwx 1 pinco pinco 8 8 mag 00:12 giorgio -> file_due

Creare una directory

Per creare una directory usiamo il comando mkdir:

mkdir nome_cartella

Montare una partizione (renderla accessibile)

Prima di tutto dobbiamo identificare la partizione. Il comando che consente di montare una partizione è mount:

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:

  • -t (type) che permette di specificare (se il filesystem non venisse automaticamente riconosciuto) il fs della partizione e puo assumere i seguenti valori: adfs, affs, autofs, coda, coherent, cramfs, devpts, efs, ext, ext2, ext3, hfs, hpfs, iso9660, jfs, minix, msdos, ncpfs, nfs, ntfs, proc, qnx4, ramfs, reiserfs, romfs, smbfs, sysv, tmpfs, udf (fs dei cd/dvd multisessione), ufs, umsdos, usbfs, vfat (valido per fat, fat16, fat32), xenix, xfs, xiafs.
    Ecco un esempio del comando con l'opzione -t:

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

  • -o (options) che permette di specificare opzioni utili, i volori indicabili sono (citiamo i più comuni):
  • async: I/O in modo asincrono
  • atime: Aggiorna la data/ora di accesso agli inode ad ogni accesso
  • defaults: usa le impostazioni di default (rw, suid, dev, exec, auto, nouser e async)
  • dev: Interpreta i device speciali a caratteri o a blocchi del file system
  • exec: permette l'esecuzione di binari
  • ro: read-only ossia solo lettura
  • rw: read-write ossia permessa la lettura e scrittura dei dati
  • sync: I/O in modo sincrono
  • suid: Abilita le funzionalità dei bit set-user-identifier o set-group-identifier.
  • user: abilita l'utente comune a montare la partizione (a senso specificarla solo nel /etc/fstab)
  • users: abilita l'utente comune a montare e/o smontare la partizione
  • noexec: non permette l'esecuzione di file binari
  • nodev: Non interpreta i device speciali a caratteri o a blocchi del file system
  • noatime: Non aggiorna la data/ora di accesso agli inode ad ogni accesso
  • nosuid: Disabilita le funzionalità dei bit set-user-identifier o set-group-identifier.
  • nouser: Non permette allo user di montare la partizione (a senso specificarla solo nel /etc/fstab)
  • nls=valore: impostiamo il "Native Language Support", molto utile per i fs NTFS usare il valore utf8
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

Smontare una partizione

Per smontare una partizione possiamo fare in due modi:

  • umount e l'identificativo della partizione, ad esempio:

    umount /dev/sda1

  • umount e il punto di montaggio:

    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 che ci mostra semplicemente il contenuto del file, il suo uso è elementare:

    cat nomefile

  • less che ci legge il documento pagina per pagina, (è possibile scorrere il testo usando le freccette e uscire dalla letture premendo il tasto q)il suo utilizzo è elementare:

    less nomefile


    Ecco alcuni tips per less (usato di default per leggere i man dei comandi):
    • /stringa permette di ricercare la stringa (insieme di caratteri) dal cursore in poi
    • ?stringa permette di ricercare la stringa dal cursore in su (fino ad inizio pagina)
    • premendo la barra spaziatrice (space) ci spostiamo di una pagina (corrisponde alle linee mostrate dalla schermata)
    • premere PagUp e PagDwon per spostarsi di una pagina (come space) indietro o avanti
    Molto simile, ma con meno funzionalità è il comando more
  • tail che visualizza l'ultima parte di un file. Molte utile se vogliamo leggere solo le utile righe di un log (come dmesg).Il suo utilizzo è elementare:

    tail nomefile

Vedere i processi in esecuzione

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

ps aux

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

[pinco ~]$ ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 3008 4.7 3.0 956748 86572 ? Sl 15:26 0:42 /usr/local/Alic
pinco 3053 1.3 0.7 77232 22396 ? SL 15:26 0:12 /usr/bin/enligh
pinco 3086 0.0 0.0 4624 564 ? Ss 15:26 0:00 /usr/bin/ssh-ag
pinco 3089 0.0 0.0 2964 656 ? S 15:26 0:00 /usr/bin/dbus-l
pinco 3090 0.0 0.0 2484 852 ? Ss 15:26 0:00 /usr/bin/dbus-d
pinco 3216 0.0 0.0 7140 2128 ? S 15:27 0:00 ivman --nofork
pinco 3234 0.0 0.2 15504 5780 ? S 15:27 0:00 bluetooth-apple
pinco 3236 0.0 0.1 6620 2856 ? S 15:27 0:00 /usr/lib/libgco
pinco 3420 0.0 0.0 5020 1416 ? Ss 15:27 0:00 /bin/sh /usr/bi
pinco 3421 0.0 0.0 5032 1428 ? S 15:27 0:00 sh ./aTunes.sh
pinco 3423 5.5 7.3 1236928 210668 ? Sl 15:27 0:46 java -Djava.lib
pinco 3540 4.0 0.6 31624 18664 ? Ss 15:32 0:23 bluefish
pinco 3575 2.6 2.0 138740 59168 ? Ssl 15:35 0:09 /usr/lib/opera/
pinco 3646 0.5 0.4 68952 12252 ? Sl 15:35 0:01 /usr/lib/opera/
pinco 3647 0.0 0.0 2788 708 ? S 15:35 0:00 /usr/lib/opera/
pinco 3802 3.4 0.8 54296 25652 ? SL 15:40 0:03 mplayer -quiet
root 3811 0.0 0.0 0 0 ? Z 15:41 0:00 [iwc] <defunct>
pinco 3816 11.6 0.5 38756 15092 ? Ssl 15:41 0:00 gnome-terminal
pinco 3818 0.6 0.1 25408 2868 ? Ssl 15:41 0:00 /usr/lib/bonobo
pinco 3822 0.0 0.0 2748 760 ? S 15:41 0:00 gnome-pty-helpe
pinco 3823 9.5 0.1 6856 3456 pts/0 Ss 15:41 0:00 bash
pinco 3859 0.0 0.0 4380 1012 pts/0 R+ 15:41 0:00 ps aux

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

.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

Informazioni sull hardware

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

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

lsusb

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 in GNU/Linux

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

  • r - lettura
  • w - scrittura
  • x - esecuzione
E sono assegnati principalmente a tre soggetti:
  • Proprietario del file (user)
  • Gruppo ossia gli utenti dello stesso gruppo del proprietario (group)
  • Altri (others)
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:
  • con numero ottale
  • con caratteri (u,g,o,a,r,w,x)

Cambiare i permessi con numero ottale

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

  • i permessi del proprietario (la prima cifra)
  • i permessi del gruppo (la seconda)
  • i permessi a tutti gli altri utenti del sistema (la terza)
E ogni cifra ricaverà il valore (da 0 a 7) in base a queste regole:
  • nessun permesso = valore 0
  • permesso lettura = valore 4
  • permesso scrittura = valore 2
  • permesso esecuzione = valore 1

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:

  • Permesso di lettura, scrittura e esecuzione al proprietario, permesso di sola letture agli altri soggetti:

    pinco@linux ~ $ chmod 744 file_uno
    pinco@linux ~ $ ls -l
    -rwxr--r-- 1 pinco pinco 0 12 mag 21:04 file_uno

  • Tutti i permessi al proprietario, agli utenti del gruppo sola esecuzione, agli altri nessun permesso

    pinco@linux ~ $ chmod 710 file_uno
    pinco@linux ~ $ ls -l
    -rwx--x--- 1 pinco pinco 0 12 mag 21:04 file_uno

  • Permesso di lettura e scrittura al proprietario, scrittura al gruppo, esecuzione agli altri

    pinco@linux ~ $ chmod 621 file_uno
    pinco@linux ~ $ ls -l
    -rw--w---x 1 pinco pinco 0 12 mag 21:04 file_uno

  • Nessun permesso a tutti

    pinco@linux ~ $ chmod 000 file_uno
    pinco@linux ~ $ ls -l
    ---------- 1 pinco pinco 0 12 mag 21:04 file_uno

Cambiare i permessi usando dei 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:

  • u identifica il proprietario (user)
  • g identifica gli utenti dello stesso gruppo del proprietario (group)
  • o identifica tutti gli altri utenti del sistema (others)
  • a (all) identifica tutti gli utenti del sistema (dal proprietario fino agli utenti estranei)
Con:
  • - si toglie un permesso
  • + si concede un permesso
I permessi ovviamente possono essere di tre tipi:
  • r lettura
  • w scrittura
  • x esecuzione
Quindi per assegnare dei permessi ai file basta usare chmod con questa sintassi

chmod soggetto=simbolo tipo_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
  • Con questo comando daremo i permessi di scrittura a tutti gli utenti del sistema

    pinco@linux ~ $ chmod a=+w file_uno
    pinco@linux ~ $ ls -l
    --w--w--w- 1 pinco pinco 0 12 mag 21:04 file_uno

  • Con questo comando daremo tutti i permessi all'utente e nessuno agli altri soggetti

    pinco@linux ~ $ chmod u=+rwx,go=-rwx file_uno
    pinco@linux ~ $ ls -l
    -rwx------ 1 pinco pinco 0 12 mag 21:04 file_uno

  • Con questo comando daremo il permesso di scrittura solo al proprietario del file

    pinco@linux ~ $ chmod u+w file_uno
    pinco@linux ~ $ ls -l
    --w------- 1 pinco pinco 0 12 mag 21:04 file_uno

  • Con questo comando daremo il permesso di lettura a tutti gli utenti del sistema

    pinco@linux ~ $ chmod a+r file_uno
    pinco@linux ~ $ ls -l
    -r--r--r-- 1 pinco pinco 0 12 mag 21:04 file_uno

  • con questo comando daremo il permesso di lettura al gruppo

    pinco@linux ~ $ chmod g+r file_uno
    pinco@linux ~ $ ls -l
    ----r----- 1 pinco pinco 0 12 mag 21:04 file_uno

  • Con questo comando daremo il permesso di esecuzione agli altri utenti

    pinco@linux ~ $ chmod o+x file_uno
    pinco@linux ~ $ ls -l
    ---------x 1 pinco pinco 0 12 mag 21:04 file_uno

  • Con questo comando daremo il permesso a tutti su tutto

    pinco@linux ~ $ chmod ugo=+rwx file_uno
    pinco@linux ~ $ ls -l
    -rwxrwxrwx 1 pinco pinco 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

pinco@linux # ls -l
-rwxrwxrwx 1 pinco pinco 0 11 set 21:04 file_uno
pinco@linux # chown root file_uno
pinco@linux # ls -l
-rwxrwxrwx 1 root pinco 0 11 set 21:04 file_uno

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

pinco@linux ~ $ ls -l
drwxr-xr-x 2 pinco pinco 4096 02 gen 12:25 prova
pinco@linux ~ $ ls -l prova/
-rw-r--r-- 1 pinco pinco 0 02 gen 12:25 file_uno
pinco@linux # chown -R root prova
pinco@linux # ls -l
drwxr-xr-x 2 root pinco 4096 02 gen 12:25 prova
pinco@linux # ls -l prova/
-rw-r--r-- 1 root pinco 0 02 gen 12:25 file_uno

Cambiare il gruppo di appartenza di un file

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

chgrp gruppo file

Una opzione è -R, che cambia ricorsivamente il gruppo proprietario per tutti i file contenuti in una directory:

chgrp -R gruppo cartella

Ad esempio:

pinco@linux ~ $ ls -l
drwxr-xr-x 2 pinco pinco 3813 11 set 14:20 prova
pinco@linux ~ $ ls -l prova/
-rw-r--r-- 1 pinco pinco 0 02 gen 12:23 file_uno
pinco@linux # chgrp -R root prova
pinco@linux # ls -l
drwxr-xr-x 2 pinco root 3813 11 set 14:20 prova
pinco@linux # ls -l prova/
-rw-r--r-- 1 pinco root 0 02 gen 12:23 file_uno

Fermare 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

Ad esempio:

kill 5364

Per forzare l'arresto di un processo, nel caso questo non rispondesse al classico segnale, potete usare l'opzione -9:

kill -9 PID

ad esempio:

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:

pinco@linux ~ $ lsmod
Module Size Used by
zlib_deflate 20024 1 ppp_deflate
crc_ccitt 1836 1 ppp_async
ppp_generic 25216 3 ppp_deflate,bsd_comp,ppp_async
slhc 6028 1 ppp_generic
usbserial 31464 1 option
nls_base 6896 2 nls_utf8,isofs
nvidia 9587208 26
agpgart 34572 1 nvidia
rfcomm 36796 2
l2cap 22700 9 rfcomm
bluetooth 54020 4 rfcomm,l2cap
cpufreq_userspace 2832 2
ext4 234252 1
jbd2 56100 1 ext4
crc16 1804 1 ext4
fuse 57192 1
snd_hda_codec_realtek 196144 1
snd_hda_intel 25128 4
snd_hda_codec 74540 2 snd_hda_codec_realtek,snd_hda_intel
snd_hwdep 7120 1 snd_hda_codec
snd_mixer_oss 15852 1 snd_pcm_oss
snd_pcm 74384 4 snd_hda_intel,snd_hda_codec,snd_pcm_oss
snd_rawmidi 21632 1 snd_seq_midi
snd_seq_midi_event 6956 2 snd_seq_oss,snd_seq_midi
snd_seq 50352 6 snd_seq_dummy,snd_seq_oss,snd_seq_midi,snd_seq_midi_event
snd_timer 20788 3 snd_pcm,snd_seq
snd_seq_device 6904 5 snd_seq_dummy,snd_seq_oss,snd_seq_midi,snd_rawmidi,snd_seq
snd 57220 18
snd_page_alloc 8852 2 snd_hda_intel,snd_pcm
i2c_core 23872 2 nvidia,i2c_nforce2
processor 34496 1 acpi_cpufreq
evdev 9568 3
ext3 127060 5
jbd 45568 1 ext3
mbcache 7440 2 ext4,ext3
cdrom 35456 1 sr_mod
sd_mod 34824 8
crc_t10dif 1676 1 sd_mod
mii 5164 1 r8169
ahci 33020 7
ide_core 101736 2 ide_pci_generic,amd74xx
libata 174380 2 ahci,ata_generic
scsi_mod 151156 5 usb_storage,sg,sr_mod,sd_mod,libata
usbcore 148560 6 option,usbserial,usb_storage,ehci_hcd,ohci_hcd
thermal_sys 15476 3 processor,thermal,fan

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):

pinco@linux # 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:

pinco@linux # modprobe drm

Informazioni su un modulo del kernel

Per avere qualche informazione in più 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:
  • -m indica al sistema di creare per il nuovo utente una nuova home (/home/utente) con tutti i file base predefiniti. Nel caso in cui ci serva un utente solo per far girare un servizio (tipico esempio è un utente creato ad hoc per far girare un demone p2p) possiamo evitare questa opzione
  • -G gruppo1,gruppo2 Con questa opzione indichiamo i gruppi a cui l'utente apparterrà fin da subito (ovviamente poi se ne potranno aggiungere altri). I gruppi comuni a quasi tutti i sistema GNU/Linux sono:
    • users: gruppo in generale degli utenti
    • audio: abilita l'accesso ai dispositivi audio
    • cdrom: abilita l'accesso diretto ai dispositivi ottici
    • floppy: abilita l'accesso diretto ai floppy
    • games: abilita il gioco
    • usb: abilita l'accesso ai dispositivi USB
    • plugdev: concede la possibilità di monstare ed utilizzre unità rimovibili quali memorie USB o macchine fotografiche.
    • video: abilita l'accesso all'hardware e all'accelerazione
    • wheel: abilita l'utilizzo di su
    • haldaemon: come per plugdev, serve per l'automount
  • -s /bin/bash: indica la shell predefinita dell'utente
Altre opzioni utili sono:
  • -e MM/GG/AA: la data in cui l'account dell'utente verrà disabilitato
  • -u VALORE_UID: opzione per assegnare uno specifico UID all'utente (vedere man useradd per avere maggiori info)

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 è usando il comando passwd:

passwd utente

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

passwd

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.

comando1 | comando2

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

pinco@linux # 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
pinco@linux # 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 dispositivi 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:

pinco@linux ~ $ echo buongiorno && echo giorgio
buongiorno
giorgio

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

pinco@linux ~ $ cd ... && echo buonanotte
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 e di eseguirli solo se il comando precedente è stato eseguito con successo. La sintassi è questa:

comando1; comando2

esempio:

pinco@linux ~ $ cat /var/log/messages; dmesg

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:

pinco@linux ~ $ cat buongiorno.txt
buongiorno1
buongiorno2
buongiorno3
buongiorno1 buongiorno2
pinco@linux ~ $ cat buongiorno.txt | grep buongiorno2
buongiorno2
buongiorno1 buongiorno2

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 specidfica stringa. Il comando grep è fondatamentale quando stiamo cercando qualcosa in file molto grossi come un log:

[pinco ~]$ dmesg | grep sda
[ 0.000000] Kernel command line: root=UUID=07f3a1d1-5299-4f11-afa7-56dc04e77f8a[...]
[ 0.855352] TuxOnIce: Can't translate "/dev/sda9" into a device id yet.
[ 2.566247] sd 0:0:0:0: [sda] 312581808 512-byte hardware sectors: (160 GB/149 GiB)
[ 2.566261] sd 0:0:0:0: [sda] Write Protect is off
[ 2.566263] sd 0:0:0:0: [sda] Mode Sense: 00 3a 00 00
[ 2.566281] sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
[ 2.566377] sda: sda1 sda2 < sda5 sda6 sda7 sda8 sda9 > sda3
[ 2.659866] sd 0:0:0:0: [sda] Attached SCSI disk
[ 9.205453] Adding 2088408k swap on /dev/sda9. Priority:-1 extents:1 across:2088408k
[ 9.650515] EXT3 FS on sda5, internal journal
[ 124.608175] Adding 2088408k swap on /dev/sda9. Priority:-1 extents:1 across:2088408k
[ 125.111974] EXT3 FS on sda1, internal journal
[ 125.141605] EXT3 FS on sda3, internal journal
[ 125.273125] kjournald2 starting: pid 2234, dev sda6:8, commit interval 5 seconds
[ 125.273262] EXT4 FS on sda6, internal journal on sda6:8
[ 125.273659] EXT4-fs: mounted filesystem sda6 with ordered data mode
[ 125.310634] EXT3 FS on sda7, internal journal
[ 125.325397] EXT3 FS on sda8, internal journal
[11523.569265] sd 0:0:0:0: [sda] Synchronizing SCSI cache
[11524.424051] sd 0:0:0:0: [sda] Starting disk
[pinco3 ~]$

Come è possibile vedere ho facilmente estrapolato tutti i riferimenti a sda (un disco SATA) dentro a dmesg.
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:

pinco@linux ~ $ 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

pinco@linux ~ $ mioscript &
[1] 3924
pinco@linux ~ $

Faccio notare che viene fornito il numero di job (in questo caso 1). A questo punto il comando puo essere "recuperato" in foregroung 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

pinco@linux ~ $ 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 backgroung il processo attraverso in numero di job

pinco@linux ~ $ bg %1
[1]+ mio_script &

e semmai recuperarlo con

pinco@linux ~ $ 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

Leggere il manuale

man

La prima fonte che dobbiamo consultare in caso di dubbi su un comando, è il man di quest'ultimo. Per visualizzare il manuale di un comando usiamo man seguito dal comando:

man comando

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 --help:

comando --help

Vediamone un esempio:

pinco@linux ~ $ 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.

***

Indice | Torna in alto